@globalpayments/vega 2.101.0 → 2.102.0

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/code-block-renderer.d.ts

@@ -5,6 +5,7 @@ import { RTECodeBlock } from '../../blocks/code-block';
  * The code block renderer.
  */
 declare class RTECodeBlockRenderer extends RTEBlockRenderer {
+  static readonly typeName: string;
   /**
    * Render the code block.
    *

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/html-block-renderer.d.ts

@@ -2,6 +2,7 @@ import type { RTEHtmlBlock } from '../../blocks/html-block';
 import { RTERenderContext } from '../../../interface';
 import { RTEBlockRenderer } from './block-renderer.abstract';
 declare class RTEHTMLBlockRenderer extends RTEBlockRenderer {
+  static readonly typeName: string;
   render(block: RTEHtmlBlock, renderContext: RTERenderContext): HTMLElement;
 }
 declare const _default: RTEHTMLBlockRenderer;

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/image-block-renderer.d.ts

@@ -2,6 +2,7 @@ import { RTEImageBlock } from '../../blocks/image-block';
 import { RTEBlockRenderer } from './block-renderer.abstract';
 import { RTERenderContext } from '../../../interface';
 declare class RTEImageBlockRenderer extends RTEBlockRenderer {
+  static readonly typeName: string;
   render(block: RTEImageBlock, renderContext: RTERenderContext): HTMLElement;
 }
 declare const _default: RTEImageBlockRenderer;

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/link-wrapper-renderer.d.ts

@@ -13,11 +13,12 @@ declare class RTELinkWrapperRenderer {
    * @param {RTERenderContext} context - Context containing render options.
    * @returns {VegaRTERenderResult[]} - Array of rendered HTML elements.
    */
-  render(nodes: RTETextNode[], linkGroupAnnotation: LinkGroupAnnotation, { editable, host }: RTERenderContext): VegaRTERenderResult[];
+  render(nodes: RTETextNode[], linkGroupAnnotation: LinkGroupAnnotation, renderContext: RTERenderContext): VegaRTERenderResult[];
   private groupNodesByLink;
   private isLinkGroup;
   private renderLinkEditorWrapper;
   private renderLink;
+  private handleBookmarkNavigation;
   private normalizeLinkNodesByDefaultProtocol;
   private normalizeUrlByDefaultProtocol;
   private handleChange;

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/list-block-renderer.d.ts

@@ -2,6 +2,7 @@ import { RTEBlockRenderer } from './block-renderer.abstract';
 import { RTEListBlock } from '../../blocks/list-block';
 import { RTERenderContext } from '../../../interface';
 declare class RTEListBlockRenderer extends RTEBlockRenderer {
+  static readonly typeName: string;
   render(block: RTEListBlock, renderContext: RTERenderContext): HTMLElement;
   private resolveListMarker;
   private getListDepth;

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/list-item-block-renderer.d.ts

@@ -2,6 +2,7 @@ import { RTEListItemBlock } from '../../blocks/list-item-block';
 import { RTERenderContext } from '../../../interface';
 import { RTEBlockTextNodesRenderer } from './block-text-nodes-renderer.abstract';
 declare class RTEListItemBlockRenderer extends RTEBlockTextNodesRenderer {
+  static readonly typeName: string;
   render(block: RTEListItemBlock, renderContext: RTERenderContext): HTMLElement;
   /**
    * Include structural ownership and direct nested-list identity in the key so

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/text-block-renderer.d.ts

@@ -2,6 +2,7 @@ import { RTERenderContext } from '../../../interface';
 import { RTETextBlock } from '../../blocks/text-block';
 import { RTEBlockTextNodesRenderer } from './block-text-nodes-renderer.abstract';
 declare class RTETextBlockRenderer extends RTEBlockTextNodesRenderer {
+  static readonly typeName: string;
   render(block: RTETextBlock, renderContext: RTERenderContext): HTMLElement;
   /**
    * Returns the promotable inline HTML tag when the block wraps exactly one

package/dist/types/components/vega-rich-text-editor/dto/renderers/nodes/code-block-node-renderer.d.ts

@@ -2,6 +2,7 @@ import { RTENodeRenderer } from './node-renderer.abstract';
 import { RTERenderContext } from '../../../interface';
 import { RTECodeBlockNode } from '../../nodes/code-block-node';
 declare class RTECodeBlockNodeRenderer extends RTENodeRenderer {
+  static readonly typeName: string;
   render(node: RTECodeBlockNode, renderContext: RTERenderContext): HTMLElement;
   /**
    * Sync the code block DTO language and content when the component change event emit.

package/dist/types/components/vega-rich-text-editor/dto/renderers/nodes/image-node-renderer.d.ts

@@ -2,6 +2,7 @@ import { RTENodeRenderer } from './node-renderer.abstract';
 import { RTEImageNode } from '../../nodes/image-node';
 import { RTERenderContext } from '../../../interface';
 declare class RTEImageNodeRenderer extends RTENodeRenderer {
+  static readonly typeName: string;
   render(node: RTEImageNode, renderContext: RTERenderContext): HTMLElement;
   /**
    * The function will render an image.

package/dist/types/components/vega-rich-text-editor/dto/renderers/nodes/node-renderer.abstract.d.ts

@@ -3,6 +3,7 @@ import { Nullable } from '../../../../../types/general';
 import { RTENode } from '../../nodes/node.abstract';
 import { VegaRTEBaseRenderer } from '../base-renderer';
 export declare abstract class RTENodeRenderer extends VegaRTEBaseRenderer<RTENode, HTMLElement> {
+  static readonly typeName: string;
   abstract render(node: RTENode, renderContext?: RTERenderContext): HTMLElement;
   protected registerRef(ref: Nullable<HTMLElement>, node: RTENode): void;
 }

package/dist/types/components/vega-rich-text-editor/dto/renderers/nodes/text-node-renderer.d.ts

@@ -4,6 +4,7 @@ import { RTETextNode } from '../../nodes/text-node';
 import { Nullable } from '../../../../../types/general';
 import { InlineHtmlAnnotation } from '../../annotations/inline-html-annotation';
 declare class RTETextNodeRenderer extends RTENodeRenderer {
+  static readonly typeName: string;
   /**
    * Renders the text node wrapped in the given annotation chain starting from the
    * provided annotation level. Used by the grouped node renderer to render a node

package/dist/types/components/vega-rich-text-editor/extensions/base-extension-renderer.d.ts

@@ -9,6 +9,7 @@ declare type VegaRTEUseRef = (element: HTMLElement) => void;
  * Base renderer for Vega Rich Text Editor.
  */
 export declare abstract class VegaRTEExtensionRenderer extends VegaRTEBaseRenderer<RTEBlock | RTENode, VegaRTERenderResult> {
+  static readonly typeName: string;
   static REGISTER_REF_FLAG: string;
   /**
    * Returns the styles to be injected into the RTE scope.

package/dist/types/components/vega-rich-text-editor/extensions/blockquote/dto/rte-blockquote-block.d.ts

@@ -19,8 +19,7 @@ export declare type RTEBlockquoteParent = VegaRTEContent | RTEBlock;
  * DTO representing a `<blockquote>` block.
  */
 export declare class RTEBlockquoteBlock extends RTEBlock<RTEBlockquoteParent, RTEBlock> {
-  static readonly dtoName: string;
-  readonly dtoName: string;
+  static readonly typeName: string;
   type: string;
   parent: RTEBlockquoteParent;
   children: RTEBlock[];

package/dist/types/components/vega-rich-text-editor/extensions/blockquote/renderers/blockquote-block-renderer.d.ts

@@ -5,6 +5,7 @@ import { RTEBlockquoteBlock } from '../dto/rte-blockquote-block';
  * Renderer for blockquote blocks in the rich text editor.
  */
 export declare class RTEBlockquoteBlockRenderer extends VegaRTEExtensionRenderer {
+  static readonly typeName: string;
   /**
    * @inheritDoc
    */

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/action-handler-interceptors/delete-bookmark-before-text-interceptor.d.ts

@@ -0,0 +1,16 @@
+import { ActionHandlerExecution, ActionHandlerInterceptor } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
+import { DeleteBlockContentAction } from '../../../dto/actions/delete-block-content-action';
+import type { RTETextBlock } from '../../../dto/blocks/text-block';
+/**
+ * Removes a bookmark when Backspace is pressed at the start of its following text node.
+ */
+export declare class DeleteBookmarkBeforeTextInterceptor extends ActionHandlerInterceptor<DeleteBlockContentAction, RTETextBlock> {
+  /**
+   * @inheritDoc
+   */
+  canIntercept(action: DeleteBlockContentAction, target: RTETextBlock): boolean;
+  /**
+   * @inheritDoc
+   */
+  intercept(_execution: ActionHandlerExecution, action: DeleteBlockContentAction, target: RTETextBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/action-handler-strategies/insert-bookmark-node-strategy.d.ts

@@ -0,0 +1,12 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import type { RTETextBlock } from '../../../dto/blocks/text-block';
+import { InsertBookmarkNodeAction } from '../actions/insert-bookmark-node-action';
+/**
+ * Strategy to handle the insertion of a bookmark node into the nearest root block.
+ */
+export declare class InsertBookmarkNodeStrategy extends ActionHandleStrategy<InsertBookmarkNodeAction, RTETextBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: InsertBookmarkNodeAction, block: RTETextBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/action-handler-strategies/update-bookmark-name-strategy.d.ts

@@ -0,0 +1,12 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { RTEBookmarkNode } from '../bookmark-node';
+import { UpdateBookmarkNameAction } from '../actions/update-bookmark-name-action';
+/**
+ * Strategy to rename an existing bookmark node.
+ */
+export declare class UpdateBookmarkNameStrategy extends ActionHandleStrategy<UpdateBookmarkNameAction, RTEBookmarkNode> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: UpdateBookmarkNameAction, node: RTEBookmarkNode): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/actions/insert-bookmark-node-action.d.ts

@@ -0,0 +1,16 @@
+import { Nullable } from '../../../../../types/general';
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTERange } from '../../../dto/range';
+export declare const INSERT_BOOKMARK_NODE: string;
+/**
+ * Action to insert a bookmark node at a specified range in the Rich Text Editor.
+ *
+ * @example block.apply(new InsertBookmarkNodeAction(rteRange, 'Rights'));
+ */
+export declare class InsertBookmarkNodeAction extends ModifyContentAction {
+  type: string;
+  name: string;
+  rteRange: Nullable<RTERange>;
+  actionHandleResult: boolean;
+  constructor(rteRange: Nullable<RTERange>, name: string);
+}

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/actions/update-bookmark-name-action.d.ts

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

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/anchor-to-bookmark-node-strategy.d.ts

@@ -0,0 +1,52 @@
+import { Nullable } from '../../../../types/general';
+import { VegaRTECustomNode } from '../../interface';
+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 declare class AnchorToBookmarkNodeStrategy extends ElementToDTOStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[]): Nullable<VegaRTECustomNode>;
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks(): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+  /**
+   * 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.
+   */
+  private isBookmarkAnchor;
+  /**
+   * 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.
+   */
+  private resolveBookmarkName;
+  /**
+   * Checks whether the anchor has no meaningful content.
+   *
+   * @param {HTMLElement} element - The anchor element.
+   * @returns {boolean} True when the anchor is effectively empty.
+   */
+  private isEmptyAnchor;
+}

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/assets/bookmark.d.ts

@@ -0,0 +1,5 @@
+import { IconPayload } from '../../../../../helpers/icon/interface';
+export declare const BOOKMARK_ICON_VIEW_BOX: string;
+export declare const BOOKMARK_ICON_PATH: string;
+declare const _default: IconPayload;
+export default _default;

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/bookmark-extension.d.ts

@@ -0,0 +1,16 @@
+import { VegaRTEExtension } from '../extension.abstract';
+/**
+ * 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 declare class VegaRTEBookmarkExtension extends VegaRTEExtension {
+  static readonly TOOLBAR_BUTTON_KEY: string;
+  private bookmarkRenderer;
+  constructor();
+  /** @inheritDoc */
+  prepareBeforeLoad(host: HTMLVegaRichTextEditorElement): void;
+  /** Removes the per-host bookmark selection listener when the editor is destroyed. */
+  destroyExtension(): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/bookmark-node.d.ts

@@ -0,0 +1,62 @@
+import { AnnotationAction } from '../../dto/actions/annotation-action.abstract';
+import { RTETextBlock } from '../../dto/blocks/text-block';
+import { RTETextNode } from '../../dto/nodes/text-node';
+import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTEBookmarkNode } from '../../interface';
+/**
+ * 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 declare class RTEBookmarkNode extends RTETextNode {
+  static readonly typeName: string;
+  static dtoName: string;
+  readonly dtoName: string;
+  readonly type: string;
+  name: string;
+  constructor(id: string, name: string, parentBlock: RTETextBlock, annotations?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
+  /**
+   * @inheritDoc
+   */
+  static from(value: VegaRTEBookmarkNode, parent: RTETextBlock): RTEBookmarkNode;
+  /**
+   * Converts the bookmark node to a JSON representation.
+   *
+   * @returns {VegaRTEBookmarkNode} - The JSON representation of the bookmark node.
+   */
+  toJSON(): VegaRTEBookmarkNode;
+  /**
+   * Bookmarks are markers only, so their content can never be edited directly.
+   *
+   * @returns {boolean} - Always returns false for bookmark nodes.
+   */
+  isContentEditable(): boolean;
+  /**
+   * Clones the bookmark node.
+   *
+   * @param {RTETextBlock} parent - The parent block for the cloned node.
+   * @returns {RTEBookmarkNode} - The cloned bookmark node.
+   */
+  clone(parent: RTETextBlock): RTEBookmarkNode;
+  /**
+   * Checks if a node is empty
+   *
+   * @returns {boolean}  It returns `true` if the node is empty
+   */
+  isEmpty(): boolean;
+  /**
+   * 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(): string;
+  /**
+   * Bookmarks do not accept text formatting, but still process selection annotations.
+   *
+   * @param {AnnotationAction} action - The annotation action to apply.
+   */
+  protected doAnnotationActionApply(action: AnnotationAction): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/renderers/bookmark-node-renderer.d.ts

@@ -0,0 +1,128 @@
+import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTEBookmarkNode } from '../bookmark-node';
+/**
+ * Bookmark node renderer for the rich text editor.
+ *
+ * The bookmark always renders as an anchor so it stays a valid local link target. In editable mode
+ * the anchor also carries the marker icon and is wrapped by the bookmark editor popover.
+ */
+export declare class RTEBookmarkNodeRenderer extends VegaRTEExtensionRenderer {
+  static readonly typeName: string;
+  private static readonly SELECTED_CLASS;
+  private readonly rangeHighlightHandlers;
+  private openPopoverNode;
+  /**
+   * Renders the bookmark node.
+   *
+   * @param {VegaRTECreateElementFunction} createElement - The function to create a DOM element.
+   * @param {RTEBookmarkNode} node - The bookmark node to render.
+   * @param {RTERenderContext} editorContent - The editor content context.
+   * @returns {VegaRTERenderResult} - The rendered DOM element.
+   */
+  doRender(createElement: VegaRTECreateElementFunction, node: RTEBookmarkNode, editorContent?: RTERenderContext): VegaRTERenderResult;
+  /**
+   * @inheritDoc
+   */
+  injectRTEScopeStyles(): string;
+  /**
+   * Removes the per-host selection listener so a destroyed host is not retained by the document.
+   *
+   * @param {HTMLVegaRichTextEditorElement} host - The editor host being torn down.
+   */
+  teardownRangeHighlight(host: HTMLVegaRichTextEditorElement): void;
+  /**
+   * Renders a visible bookmark target without editor interactions.
+   *
+   * @param {VegaRTECreateElementFunction} createElement - The function to create a DOM element.
+   * @param {RTEBookmarkNode} node - The bookmark node to render.
+   * @returns {VegaRTERenderResult} - The rendered bookmark element.
+   */
+  private renderReadonlyBookmark;
+  /**
+   * Renders the in-editor bookmark anchor wrapped by its editor popover.
+   *
+   *
+   * @param {VegaRTECreateElementFunction} createElement - The function to create a DOM element.
+   * @param {RTEBookmarkNode} node - The bookmark node to render.
+   * @param {RTERenderContext} editorContent - The editor content context.
+   * @returns {VegaRTERenderResult} - The rendered bookmark element.
+   */
+  private renderEditableBookmark;
+  /**
+   * Renders the bookmark icon as inline SVG so the browser paints the text selection over it.
+   *
+   * @param {VegaRTECreateElementFunction} createElement - The function to create a DOM element.
+   * @returns {VegaRTERenderResult} - The rendered icon.
+   */
+  private renderIcon;
+  /**
+   * Places the caret right after the bookmark so typing appends text and Backspace removes the bookmark.
+   *
+   * @param {RTEBookmarkNode} node - The bookmark node.
+   * @param {RTERenderContext} editorContent - The editor content context.
+   */
+  private placeCaretAfterBookmark;
+  /**
+   * Shows the selected outline on the bookmark while its editor balloon is open.
+   *
+   * The popover lives in the editor shadow root, so its events only reach the editor element.
+   * Stencil reuses the element across renders, so the listeners are replaced instead of stacked.
+   *
+   * @param {HTMLElement} editor - The bookmark editor element.
+   */
+  private bindSelectedStateToBalloon;
+  private readonly handleBalloonShow;
+  private readonly handleBalloonHide;
+  /**
+   * Binds a single debounced selection listener per host that keeps the range highlight in sync.
+   *
+   * @typedef HTMLVegaRichTextEditorElement - The rich text editor host element.
+   * @param {HTMLVegaRichTextEditorElement} [host] - The editor host owning the bookmarks.
+   */
+  private ensureRangeHighlight;
+  /**
+   * Highlights every bookmark the current non-collapsed selection crosses.
+   *
+   * @typedef HTMLVegaRichTextEditorElement - The rich text editor host element.
+   * @param {HTMLVegaRichTextEditorElement} host - The editor host owning the bookmarks.
+   */
+  private syncRangeHighlight;
+  /**
+   * Resolves the bookmark anchor that owns the balloon which raised the event.
+   *
+   * @param {Event} e - The balloon event.
+   * @returns {Nullable<HTMLElement>} - The bookmark anchor element.
+   */
+  private getBookmarkAnchor;
+  /**
+   * Resolves the bookmark node backing an anchor element.
+   *
+   * @param {HTMLElement} anchor - The bookmark anchor element.
+   * @returns {Nullable<RTEBookmarkNode>} - The backing bookmark node, or null when the anchor is not a bookmark.
+   */
+  private getBookmarkNodeByAnchor;
+  /**
+   * Collects the bookmark names already used by other bookmarks in the same document.
+   *
+   * @param {RTEBookmarkNode} node - The bookmark node being edited.
+   * @param {RTERenderContext} editorContent - The editor content context.
+   * @returns {string[]} - The reserved bookmark names.
+   */
+  private getReservedNames;
+  /**
+   * Applies rename and removal actions emitted by the bookmark editor.
+   *
+   * @param {CustomEvent<{ action: 'save'; name: string } | { action: 'remove' }>} e - The bookmark editor change event.
+   * @param {RTEBookmarkNode} node - The bookmark node being edited.
+   * @param {RTERenderContext} editorContent - The editor content context.
+   */
+  private handleChange;
+  /**
+   * Removes the bookmark and leaves the caret where the bookmark used to be.
+   *
+   * @param {RTEBookmarkNode} node - The bookmark node being removed.
+   * @param {HTMLVegaRichTextEditorElement} host - The rich text editor host element.
+   */
+  private removeBookmark;
+}

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/renderers/bookmark-toolbar-button-renderer.d.ts

@@ -0,0 +1,46 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult, VegaRTEToolbarRenderContext } from '../../../interface';
+import { VegaRTEToolbarButtonRenderer } from '../../base-toolbar-button-renderer';
+/**
+ * Toolbar button renderer for the bookmark extension.
+ *
+ * The button hosts the bookmark editor in insert mode and inserts a bookmark
+ * at the caret position captured when the button was activated.
+ */
+export declare class RTEBookmarkToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  private editorRef;
+  private buttonWrapperRef;
+  private pendingRange;
+  /**
+   * Renders the bookmark toolbar button wrapped in the bookmark editor.
+   *
+   * @param {VegaRTECreateElementFunction} h - Create element function.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   * @returns {VegaRTERenderResult} - The toolbar button render result.
+   */
+  render(h: VegaRTECreateElementFunction, editorContext: VegaRTEToolbarRenderContext): VegaRTERenderResult;
+  /**
+   * @inheritDoc
+   */
+  protected isDisabled(editorContext: VegaRTEToolbarRenderContext): boolean;
+  /**
+   * Captures the caret position and the reserved bookmark names before the editor opens.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   */
+  protected handleButtonClick(editorContext: VegaRTEToolbarRenderContext): void;
+  /**
+   * @inheritDoc
+   */
+  protected handleDropdownClick(): void;
+  /**
+   * Anchors the insert popover to the button, because a self anchored popover never opens.
+   */
+  private syncPopoverTarget;
+  /**
+   * Inserts the bookmark emitted by the bookmark editor at the captured caret position.
+   *
+   * @param {CustomEvent<{ action: 'save'; name: string } | { action: 'remove' }>} e - The bookmark editor change event.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   */
+  private handleEditorChange;
+}

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/utils.d.ts

@@ -0,0 +1,18 @@
+import { RTEBookmarkNode } from './bookmark-node';
+/**
+ * Recursively collects every bookmark node contained in the given entity.
+ *
+ * Walks generic `children` and list `nestList` collections so bookmarks nested in
+ * lists, tables or any custom block are all discovered.
+ *
+ * @param {unknown} entity - Content, block or node to walk.
+ * @returns {RTEBookmarkNode[]} All bookmark nodes found under the entity.
+ */
+export declare function collectBookmarkNodes(entity: unknown): RTEBookmarkNode[];
+/**
+ * Collects the names of every bookmark contained in the given entity.
+ *
+ * @param {unknown} entity - Content, block or node to walk.
+ * @returns {string[]} All bookmark names found under the entity.
+ */
+export declare function collectBookmarkNames(entity: unknown): string[];

package/dist/types/components/vega-rich-text-editor/extensions/bookmark/vega-rich-text-bookmark-editor/slimmers/controllers/bookmark-editor-controller.d.ts

@@ -0,0 +1,86 @@
+import { VegaSlimmer } from '../../../../../../../vega-slimmer/vega-slimmer-core';
+import { FormFieldValidationRule } from '../../../../../../../helpers/validator/rules/form-field-validation-rule';
+import { VegaRichTextBookmarkEditor } from '../../vega-rich-text-bookmark-editor';
+/**
+ * Coordinates bookmark editor state, popover behavior and submit actions.
+ */
+export declare class BookmarkEditorController extends VegaSlimmer {
+  protected host: VegaRichTextBookmarkEditor['host'];
+  protected mode: VegaRichTextBookmarkEditor['mode'];
+  protected isEditing: VegaRichTextBookmarkEditor['isEditing'];
+  protected name: VegaRichTextBookmarkEditor['name'];
+  protected reservedNames: VegaRichTextBookmarkEditor['reservedNames'];
+  protected target: VegaRichTextBookmarkEditor['target'];
+  protected renderer: VegaRichTextBookmarkEditor['renderer'];
+  protected translationSlimmer: VegaRichTextBookmarkEditor['translationSlimmer'];
+  protected changeEventEmitter: VegaRichTextBookmarkEditor['changeEventEmitter'];
+  /** Initializes the popover target after the component loads. */
+  componentDidLoad(): void;
+  /** Re-anchors the popover when the target element changes. */
+  watchTargetChange(): void;
+  /**
+   * Builds the validation rule enforcing the bookmark naming contract.
+   *
+   * @returns {FormFieldValidationRule<string>[]} The bookmark name validation rules.
+   */
+  getValidationRules(): FormFieldValidationRule<string>[];
+  /**
+   * Populates the form with the current record when the popover opens.
+   *
+   * @returns {Promise<void>} Resolves once the form is populated and focused.
+   */
+  handlePopoverShow(): Promise<void>;
+  /**
+   * Switches the preview balloon to the rename form.
+   *
+   * @returns {Promise<void>} Resolves once the form is populated and focused.
+   */
+  startEditing(): Promise<void>;
+  /**
+   * Checks whether the balloon currently shows the read only preview.
+   *
+   * @returns {boolean} True when the preview is visible.
+   */
+  isPreviewVisible(): boolean;
+  /**
+   * Clears transient validation state after the popover hides.
+   */
+  handlePopoverHide(): void;
+  /**
+   * Validates the current name and emits the save action.
+   *
+   * @returns {Promise<void>} Resolves once the bookmark is saved or the error is surfaced.
+   */
+  submit(): Promise<void>;
+  /**
+   * Emits the remove action for the bookmark being edited.
+   *
+   * @returns {Promise<void>} Resolves once the bookmark removal is emitted.
+   */
+  remove(): Promise<void>;
+  /**
+   * Submits on Enter and closes the popover on Escape.
+   *
+   * @param {KeyboardEvent} e - Key down event.
+   */
+  handleKeyDown(e: KeyboardEvent): void;
+  /**
+   * Populates the name field with the current bookmark name and focuses it.
+   *
+   * @returns {Promise<void>} Resolves once the field is ready for editing.
+   */
+  private populateAndFocusNameInput;
+  /**
+   * Validates a bookmark name against the supported bookmark naming rules.
+   *
+   * A valid name is non-empty, free of whitespace and unique within the document.
+   *
+   * @param {string} name - The candidate bookmark name.
+   * @returns {Nullable<string>} The translation key for the failed rule, or null when the name is valid.
+   */
+  private validateName;
+  /**
+   * Updates the popover target via the remote invocation registry.
+   */
+  private updatePopoverTarget;
+}