@globalpayments/vega 2.95.0 → 2.97.0

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/keyboard-link-handler.d.ts

@@ -0,0 +1,111 @@
+import { BaseHandler } from './base-handler';
+/**
+ * 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 declare class KeyboardLinkHandler extends BaseHandler<KeyboardEvent> {
+  private activeLinkEditor;
+  private activeLinkWrapper;
+  private linkPopoverHideHandler;
+  private linkPopoverHideOwner;
+  /**
+   * Handles keyboard shortcuts for link popover open, close, and focus behavior.
+   *
+   * @param {KeyboardEvent} [event] - The keydown event fired from the editor.
+   */
+  handleEvent(event?: KeyboardEvent): void;
+  /**
+   * Releases any registered popover-hide listener when the owning controller is torn down.
+   */
+  dispose(): void;
+  /**
+   * 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.
+   */
+  private registerLinkPopoverHideHandler;
+  /**
+   * 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.
+   */
+  private onLinkPopoverHide;
+  /**
+   * Removes the currently registered popover hide listener if present.
+   */
+  private unregisterLinkPopoverHideHandler;
+  /**
+   * 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.
+   */
+  private getFocusedLinkWrapper;
+  /**
+   * 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.
+   */
+  private getLinkEditorFromWrapper;
+  /**
+   * 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.
+   */
+  private getLinkEditorPopover;
+  /**
+   * 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.
+   */
+  private getLinkEditorPopoverContentBox;
+  /**
+   * 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.
+   */
+  private handleLinkPopoverHide;
+  /**
+   * 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.
+   */
+  private focusVisibleLinkPopoverAction;
+  /**
+   * 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.
+   */
+  private getPreferredLinkActionPopover;
+  /**
+   * 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.
+   */
+  private isLinkActionPopover;
+  /**
+   * 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.
+   */
+  private getFirstFocusableLinkActionButton;
+  /**
+   * 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.
+   */
+  private placeLinkCaretAtEnd;
+}

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

@@ -15,6 +15,7 @@ export declare class UserInputController extends VegaSlimmer {
   private forwardDeleteContentHandler;
   private backwardDeleteContentHandler;
   private insertPasteHandler;
+  private keyboardLinkHandler;
   /**
    * Adds event listener to an editable HTML element to handle user input actions.
    */
@@ -23,6 +24,12 @@ export declare class UserInputController extends VegaSlimmer {
    * Removes event listener for user input actions from an editable HTML div element.
    */
   protected removeActionListener(): void;
+  /**
+   * Dispatches editor keydown events to the keyboard link handler using the shared handler workflow.
+   *
+   * @param {KeyboardEvent} event - The keydown event fired from the editor.
+   */
+  private handleKeyboardAction;
   /**
    * When a user performs an input action within the editable element, this function is triggered.
    *

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/tools/bullets-numbers/bullets-numbers-toolbar-button-slimmer.d.ts

@@ -1,13 +1,21 @@
 import { ToolbarInternalButtonConfig } from '../toolbar-button-slimmer.abstract';
 import { VegaRichTextEditor } from '../../../../vega-rich-text-editor';
+import { ListKeyboardSlimmer } from './list-keyboard-slimmer';
 import { BulletsToolbarButtonSlimmer } from './bullets-toolbar-button-slimmer';
 import { NumbersToolbarButtonSlimmer } from './numbers-toolbar-button-slimmer';
 import { VisualModeToolbarButtonSlimmer } from '../visual-mode-toolbar-button-slimmer.abstract';
 export declare class BulletsNumbersToolbarButtonSlimmer extends VisualModeToolbarButtonSlimmer {
   protected readonly selectionController: VegaRichTextEditor['selectionController'];
+  protected readonly valueController: VegaRichTextEditor['valueController'];
+  protected readonly value: VegaRichTextEditor['value'];
+  protected readonly toolbarItems: VegaRichTextEditor['toolbarItems'];
+  protected readonly vegaRichTextEditorRenderer: VegaRichTextEditor['vegaRichTextEditorRenderer'];
   protected readonly bulletsToolbarButtonSlimmer: BulletsToolbarButtonSlimmer;
   protected readonly numbersToolbarButtonSlimmer: NumbersToolbarButtonSlimmer;
+  protected readonly listKeyboardSlimmer: ListKeyboardSlimmer;
   protected popoverRef: HTMLVegaPopoverElement;
+  disconnectedCallback(): void;
+  componentDidLoad(): void;
   componentWillRender(): void;
   constructor();
   protected renderBtnWrapper(renderBtn: (toolbarInternalButton: ToolbarInternalButtonConfig) => HTMLElement): HTMLElement;

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/tools/bullets-numbers/helper/abstract-list-keyboard-handler.d.ts

@@ -0,0 +1,99 @@
+import { Nullable } from '../../../../../../../types/general';
+import { RTEBlock } from '../../../../../dto/blocks/block.abstract';
+import { RTEListItemBlock } from '../../../../../dto/blocks/list-item-block';
+import { RTETextNode } from '../../../../../dto/nodes/text-node';
+/**
+ * Abstract base for list keyboard (Tab / Shift+Tab) handlers.
+ * Provides shared selection-normalization utilities used by both the indent
+ * and outdent concrete handlers.
+ */
+export declare abstract class AbstractListKeyboardHandler {
+  /**
+   * Filter the ordered selection down to only the "root" items —
+   * items whose ancestor is not also present in the selection.
+   *
+   * @param {RTEListItemBlock[]} selection - Ordered selected list items.
+   * @returns {RTEListItemBlock[]} Root items that do not have selected ancestors.
+   */
+  protected getOutdentRoots(selection: RTEListItemBlock[]): RTEListItemBlock[];
+  /**
+   * Check whether a list item has an ancestor that is also selected.
+   *
+   * @param {RTEListItemBlock} item - Item to inspect.
+   * @param {Set<RTEListItemBlock>} selectedItems - Selected items lookup set.
+   * @returns {boolean} True when an ancestor item is selected.
+   */
+  protected hasSelectedAncestor(item: RTEListItemBlock, selectedItems: Set<RTEListItemBlock>): boolean;
+  /**
+   * Split an ordered flat list of items into groups that share the same
+   * parent list and are contiguous siblings.
+   *
+   * @param {RTEListItemBlock[]} selection - Ordered list-item selection.
+   * @returns {RTEListItemBlock[][]} Contiguous parent-based segments.
+   */
+  protected splitSelectionIntoParentSegments(selection: RTEListItemBlock[]): RTEListItemBlock[][];
+  /**
+   * Normalize the selection and split into parent-based contiguous segments.
+   * Returns null when the result is empty.
+   *
+   * @param {RTEBlock[]} selectedBlocks - Raw selected blocks.
+   * @returns {RTEListItemBlock[][] | null} Contiguous segments or null when invalid.
+   */
+  protected normalizeToSegments(selectedBlocks: RTEBlock[]): RTEListItemBlock[][] | null;
+  /**
+   * Return the first and last RTETextNode spanning the provided blocks,
+   * or null when either boundary cannot be resolved.
+   *
+   * @param {RTEBlock[]} blocks - Blocks defining the range boundary.
+   * @returns {Nullable<[RTETextNode, RTETextNode]>} First and last boundary nodes.
+   */
+  protected getSelectionBoundary(blocks: RTEBlock[]): Nullable<[RTETextNode, RTETextNode]>;
+  /**
+   * Normalize the raw selectedBlocks into an ordered list of RTEListItemBlocks,
+   * truncating at the first non-list block.  Returns null when no list items
+   * are present.
+   *
+   * @param {RTEBlock[]} selectedBlocks - Raw selected blocks.
+   * @returns {RTEListItemBlock[] | null} Ordered list items or null.
+   */
+  protected getOrderedListItems(selectedBlocks: RTEBlock[]): RTEListItemBlock[] | null;
+  /**
+   * Collect contiguous selected list items until a non-list block is found.
+   *
+   * @param {RTEBlock[]} selectedBlocks - Raw selected blocks.
+   * @returns {RTEListItemBlock[]} Selected list items up to first non-list block.
+   */
+  protected getSelectedListItemsUntilFirstNonList(selectedBlocks: RTEBlock[]): RTEListItemBlock[];
+  /**
+   * Build a hierarchical index path for a list item in the list tree.
+   *
+   * @param {RTEListItemBlock} item - Item whose tree path is being resolved.
+   * @returns {number[]} Tree index path from root to the item.
+   */
+  protected getTreePath(item: RTEListItemBlock): number[];
+  /**
+   * Compare two list-item tree paths.
+   *
+   * @param {number[]} a - First tree path.
+   * @param {number[]} b - Second tree path.
+   * @returns {number} Negative when a < b, positive when a > b, otherwise 0.
+   */
+  protected compareTreePath(a: number[], b: number[]): number;
+  /**
+   * Check whether a value exposes a children array.
+   *
+   * @param {unknown} entity - Candidate value.
+   * @returns {boolean} True when entity has children array.
+   */
+  protected hasChildren(entity: unknown): entity is {
+    children: unknown[];
+  };
+  /**
+   * Execute the keyboard action for the given selection and return the
+   * resulting selection boundaries, or null when no action was taken.
+   *
+   * @param {RTEBlock[]} selectedBlocks - Currently selected blocks.
+   * @returns {Array<Nullable<[RTETextNode, RTETextNode]>> | null} Selection boundaries after action.
+   */
+  abstract execute(selectedBlocks: RTEBlock[]): Array<Nullable<[RTETextNode, RTETextNode]>> | null;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/tools/bullets-numbers/helper/list-shift-tab-outdent-handler.d.ts

@@ -0,0 +1,15 @@
+import { Nullable } from '../../../../../../../types/general';
+import { RTEBlock } from '../../../../../dto/blocks/block.abstract';
+import { RTETextNode } from '../../../../../dto/nodes/text-node';
+import { AbstractListKeyboardHandler } from './abstract-list-keyboard-handler';
+/**
+ * Handles Shift+Tab key list outdent.
+ * Normalizes the selection, then promotes each segment, either moving nested
+ * items or promoting top-level items to paragraphs.
+ */
+export declare class ListShiftTabOutdentHandler extends AbstractListKeyboardHandler {
+  /**
+   * @inheritDoc
+   */
+  execute(selectedBlocks: RTEBlock[]): Array<Nullable<[RTETextNode, RTETextNode]>> | null;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/tools/bullets-numbers/helper/list-tab-indent-handler.d.ts

@@ -0,0 +1,15 @@
+import { Nullable } from '../../../../../../../types/general';
+import { RTEBlock } from '../../../../../dto/blocks/block.abstract';
+import { RTETextNode } from '../../../../../dto/nodes/text-node';
+import { AbstractListKeyboardHandler } from './abstract-list-keyboard-handler';
+/**
+ * Handles Tab key list indentation.
+ * Normalizes the selection, applies a command-style gate on the first
+ * eligible segment, then nests each qualifying segment.
+ */
+export declare class ListTabIndentHandler extends AbstractListKeyboardHandler {
+  /**
+   * @inheritDoc
+   */
+  execute(selectedBlocks: RTEBlock[]): Array<Nullable<[RTETextNode, RTETextNode]>> | null;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/tools/bullets-numbers/list-keyboard-slimmer.d.ts

@@ -0,0 +1,73 @@
+import { VegaSlimmer } from '../../../../../../vega-slimmer/vega-slimmer-core';
+import { BulletsNumbersToolbarButtonSlimmer } from './bullets-numbers-toolbar-button-slimmer';
+/**
+ * Handles list keyboard shortcuts (Tab/Shift+Tab) for list tooling.
+ */
+export declare class ListKeyboardSlimmer extends VegaSlimmer {
+  protected readonly selectionController: BulletsNumbersToolbarButtonSlimmer['selectionController'];
+  protected readonly valueController: BulletsNumbersToolbarButtonSlimmer['valueController'];
+  protected readonly value: BulletsNumbersToolbarButtonSlimmer['value'];
+  protected readonly toolbarItems: BulletsNumbersToolbarButtonSlimmer['toolbarItems'];
+  protected readonly vegaRichTextEditorRenderer: BulletsNumbersToolbarButtonSlimmer['vegaRichTextEditorRenderer'];
+  private boundEditableElement;
+  private isKeyboardListenerBound;
+  private readonly listTabIndentHandler;
+  private readonly listShiftTabOutdentHandler;
+  /**
+   * @inheritDoc
+   */
+  disconnectedCallback(): void;
+  /**
+   * @inheritDoc
+   */
+  componentDidLoad(): void;
+  /**
+   * Re-sync keyboard listener when toolbarItems prop changes at runtime,
+   * ensuring list shortcuts are bound/unbound as tools are added/removed.
+   */
+  watchToolbarItems(): void;
+  /**
+   * Synchronize the DOM keydown listener with the configured toolbar items.
+   */
+  private syncListKeyboardListener;
+  /**
+   * Determine whether any list keyboard controls are enabled in the toolbar.
+   *
+   * @returns {boolean} True when any list toolbar item is configured.
+   */
+  private hasListToolbarConfigured;
+  /**
+   * Attach the keydown listener to the current editable element when available.
+   * Handles element ref changes by rebinding when the target element differs.
+   */
+  private addListKeyboardListener;
+  /**
+   * Detach the keydown listener from the previously bound editable element.
+   */
+  private removeListKeyboardListener;
+  /**
+   * Handle Tab and Shift+Tab list keyboard interactions.
+   *
+   * @param {KeyboardEvent} e - Keyboard event to process.
+   * @returns {void}
+   */
+  private handleListKeyboardAction;
+  /**
+   * Check whether the Tab event includes modifiers other than Shift.
+   *
+   * @param {KeyboardEvent} e - Keyboard event to inspect.
+   * @returns {boolean} True when non-shift modifier keys are pressed.
+   */
+  private hasNonShiftModifierForTab;
+  /**
+   * Restore the logical selection after a list keyboard action completes.
+   *
+   * @param {Array<Nullable<[RTETextNode, RTETextNode]>>} selectionBoundaries - Boundaries produced by the handler.
+   * @param {Nullable<RTETextNode>} preferredStartNode - Preferred start node from prior selection.
+   * @param {Nullable<RTETextNode>} preferredEndNode - Preferred end node from prior selection.
+   * @param {number} startOffset - Preferred start offset.
+   * @param {number} endOffset - Preferred end offset.
+   * @returns {void}
+   */
+  private restoreListSelection;
+}

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

@@ -16,7 +16,7 @@ import { LinkToolbarButtonSlimmer } from './slimmers/renderers/tools/link-toolba
 import { MoreIndentToolbarButtonSlimmer } from './slimmers/renderers/tools/more-indent-toolbar-button-slimmer';
 import { LessIndentToolbarButtonSlimmer } from './slimmers/renderers/tools/less-indent-toolbar-button-slimmer';
 import { ImageToolbarButtonSlimmer } from './slimmers/renderers/tools/image-toolbar-button-slimmer';
-import { FormFieldControllerSlimmer } from '../../helpers/slimmers/form-field-controller-slimmer';
+import { FormFieldControllerSlimmer } from '../../helpers/slimmers/form/form-field-controller-slimmer';
 import { FormFieldValidationRule } from '../../helpers/validator/rules/form-field-validation-rule';
 import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
 import { TextColorToolbarButtonSlimmer } from './slimmers/renderers/tools/text-color-toolbar-button-slimmer';
@@ -137,6 +137,14 @@ export declare class VegaRichTextEditor {
    * @vegaVersion 2.88.0
    */
   optional: boolean;
+  /**
+   * Specifies the name attribute used to identify the form field during data submission.
+   *   It functions identically to the `data-vega-form` attribute but operates at a lower priority.
+   *
+   * @default ''
+   * @vegaVersion 2.97.0
+   */
+  name: string;
   /**
    * Specifies a placeholder string that displays as a
    *    temporary hint or example within the rich text editor.

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

@@ -0,0 +1,149 @@
+import { VegaSlimmer } from '../../../../../vega-slimmer/vega-slimmer-core';
+import { NotifyObserverPayload } from '../../../../../helpers/event-manager/slimmers/child-nodes-notify-observer-slimmer';
+import { VegaRichTextLinkEditor } from '../../vega-rich-text-link-editor';
+/**
+ * Coordinates link editor state, popover behavior, and submit actions.
+ */
+export declare class LinkEditorController extends VegaSlimmer {
+  protected host: VegaRichTextLinkEditor['host'];
+  protected status: VegaRichTextLinkEditor['status'];
+  protected record: VegaRichTextLinkEditor['record'];
+  protected changeEventEmitter: VegaRichTextLinkEditor['changeEventEmitter'];
+  protected resetStatusAfterHide: VegaRichTextLinkEditor['resetStatusAfterHide'];
+  protected target: VegaRichTextLinkEditor['target'];
+  protected renderer: VegaRichTextLinkEditor['renderer'];
+  protected linkTypeConfigController: VegaRichTextLinkEditor['linkTypeConfigController'];
+  protected linkEditorStateManager: VegaRichTextLinkEditor['linkEditorStateManager'];
+  private readonly linkUrlNormalizer;
+  private readonly linkTypeHandlers;
+  /** Initializes the popover target after the component loads. */
+  componentDidLoad(): void;
+  /** Notifies observers after each render cycle. */
+  componentDidRender(): void;
+  /** Focuses the URL input when the status changes to linkEdit. */
+  watchStatusChange(): void;
+  /** Invalidates link type cache and updates the popover target when the target changes. */
+  watchTargetChange(): void;
+  /**
+   * Prepares the editor state before the popover is shown.
+   *
+   * @returns {Promise<void>} Resolves when the popover show work completes.
+   * Resolves when the popover show work completes.
+   */
+  handlePopoverShow(): Promise<void>;
+  /**
+   * Clears form state after the popover hides.
+   *
+   * @returns {void} No return value.
+   */
+  handlePopoverHide(): void;
+  /**
+   * Switches the editor into link edit mode.
+   *
+   * @returns {void} No return value.
+   */
+  handleEditAction(): void;
+  /**
+   * Removes the current selection link and closes the popover.
+   *
+   * @returns {Promise<void>} Resolves when unlinking finishes.
+   */
+  handleUnlinkAction(): Promise<void>;
+  /**
+   * Updates submit state from URL input changes.
+   *
+   * @param {CustomEvent<string>} e - URL input change event.
+   * @returns {void} No return value.
+   */
+  handleUrlVegaChange(e: CustomEvent<string>): void;
+  /**
+   * Submits the current link when Enter is pressed or hides the popover when Escape is pressed.
+   *
+   * @param {KeyboardEvent} e - Key down event.
+   * @returns {void} No return value.
+   */
+  handleKeyDown(e: KeyboardEvent): void;
+  /**
+   * Switches the active form when the link type changes.
+   *
+   * @param {NotifyObserverPayload<string>} payload - Selected link type change payload.
+   * @returns {Promise<void>} Resolves when the link type switch completes.
+   */
+  handleLinkTypeChange(payload: NotifyObserverPayload<string>): Promise<void>;
+  /**
+   * Builds and emits the final link payload.
+   *
+   * @returns {Promise<void>} Resolves when the link submit flow completes.
+   */
+  submitLink(): Promise<void>;
+  /**
+   * Populates the edit form from the active record.
+   *
+   * @returns {Promise<void>} Resolves when the edit form is populated.
+   */
+  populateEditForm(): Promise<void>;
+  /**
+   * Updates the popover target via the remote invocation registry.
+   *
+   * @returns {void} No return value.
+   */
+  private updatePopoverTarget;
+  /**
+   * Preserves an unchanged mailto URL when the form edits are equivalent.
+   *
+   * @param {Record<string, string>} formValues - Current form values.
+   * @param {string} normalizedUrl - Normalized URL candidate.
+   * @returns {string} The preserved or normalized URL.
+   */
+  private preserveExistingMailtoUrlIfUnchanged;
+  /**
+   * Normalizes a URL using the currently selected link type protocol.
+   *
+   * @param {string} url - URL to normalize.
+   * @returns {string} The normalized URL.
+   */
+  private normalizeUrlByDefaultProtocol;
+  /**
+   * Parses a mailto URL into structured parts.
+   *
+   * @param {string} url - Mailto URL to parse.
+   * @returns {MailtoUrlParts} The parsed mailto parts.
+   */
+  private parseMailtoUrl;
+  /**
+   * Builds a mailto URL from the email form fields.
+   *
+   * @param {string} emailAddress - Email address value.
+   * @param {string} subject - Subject value.
+   * @param {string} body - Body value.
+   * @returns {string} The generated mailto URL.
+   */
+  private buildEmailLinkUrl;
+  /**
+   * Enables or disables submit based on the normalized URL value.
+   *
+   * @param {string} url - URL value to evaluate.
+   * @returns {void} No return value.
+   */
+  private updateSubmitDisabledState;
+  /**
+   * Restores cached form values after the next render.
+   *
+   * @param {Record<string, string>} savedValues - Link type-specific values to restore.
+   * @returns {Promise<void>} Resolves after restoring cached values.
+   */
+  private performFormRestore;
+  /**
+   * Keeps text input UI in sync as a fallback when form setValue timing misses visual update.
+   *
+   * @param {string} textValue - Text value to display.
+   * @returns {void} No return value.
+   */
+  private syncTextInputValue;
+  /**
+   * Waits for the host to finish rendering.
+   *
+   * @returns {Promise<unknown>} A promise that resolves after the host renders.
+   */
+  private waitForRender;
+}

package/dist/types/components/vega-rich-text-editor/vega-rich-text-link-editor/slimmers/controllers/link-editor-state-manager.d.ts

@@ -0,0 +1,84 @@
+import { VegaSlimmer } from '../../../../../vega-slimmer/vega-slimmer-core';
+/**
+ * Stores link editor state across popover interactions.
+ */
+export declare class LinkEditorStateManager extends VegaSlimmer {
+  private isSubmitDisabled;
+  private selectedLinkTypeKey;
+  private shouldResetStatusOnNextShow;
+  private formValuesByType;
+  private sharedTextValue;
+  /**
+   * Returns whether submit is currently disabled.
+   *
+   * @returns {boolean} True when submit is disabled.
+   */
+  getIsSubmitDisabled(): boolean;
+  /**
+   * Updates the submit disabled state.
+   *
+   * @param {boolean} isSubmitDisabled - Next disabled state.
+   * @returns {void} No return value.
+   */
+  setSubmitDisabled(isSubmitDisabled: boolean): void;
+  /**
+   * Returns the selected link type key.
+   *
+   * @returns {string} The selected link type key.
+   */
+  getSelectedLinkTypeKey(): string;
+  /**
+   * Updates the selected link type key.
+   *
+   * @param {string} selectedLinkTypeKey - Next link type key.
+   * @returns {void} No return value.
+   */
+  setSelectedLinkTypeKey(selectedLinkTypeKey: string): void;
+  /**
+   * Returns whether the status should reset on the next show.
+   *
+   * @returns {boolean} True when the next show should reset the status.
+   */
+  getShouldResetStatusOnNextShow(): boolean;
+  /**
+   * Updates whether the status should reset on the next show.
+   *
+   * @param {boolean} shouldResetStatusOnNextShow - Next reset flag.
+   * @returns {void} No return value.
+   */
+  setShouldResetStatusOnNextShow(shouldResetStatusOnNextShow: boolean): void;
+  /**
+   * Clears all cached form values.
+   *
+   * @returns {void} No return value.
+   */
+  clearFormValues(): void;
+  /**
+   * Returns the text value shared across link types.
+   *
+   * @returns {string} Shared text value.
+   */
+  getSharedTextValue(): string;
+  /**
+   * Updates the text value shared across link types.
+   *
+   * @param {string} textValue - Next shared text value.
+   * @returns {void} No return value.
+   */
+  setSharedTextValue(textValue: string): void;
+  /**
+   * Stores form values for a given link type key.
+   *
+   * @param {string} linkTypeKey - Link type cache key.
+   * @param {Record<string, string>} formValues - Form values to cache.
+   * @returns {void} No return value.
+   */
+  cacheFormValues(linkTypeKey: string, formValues: Record<string, string>): void;
+  /**
+   * Returns cached form values for a given link type key.
+   *
+   * @param {string} linkTypeKey - Link type cache key.
+   * @returns {Record<string, string> | undefined} The cached form values, if any.
+   */
+  getCachedFormValues(linkTypeKey: string): Record<string, string> | undefined;
+}