@globalpayments/vega 2.99.0 → 2.100.0

package/dist/types/components/vega-button/vega-button.d.ts

@@ -8,6 +8,7 @@ import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event
 import { ChildNodesEventPreventSlimmer } from '../../helpers/event-manager/slimmers/child-nodes-event-prevent-slimmer';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 import { VegaButtonLoadingRenderer } from './slimmers/renderers/vega-button-loading-renderer';
+import { AriaAttributesValueMapper } from '../../helpers/slimmers/mutation-observer/aria-attributes-value-mapper';
 /**
  * Buttons are used for triggering actions.
  *
@@ -24,6 +25,7 @@ export declare class VegaButton {
   protected eventPrevent: ChildNodesEventPreventSlimmer;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaButtonElement>;
   protected vegaButtonLoadingRenderer: VegaButtonLoadingRenderer;
+  protected ariaAttributesValueMapper: AriaAttributesValueMapper;
   host: HTMLVegaButtonElement;
   currentBreakpoint: BreakpointsTokenType;
   /**

package/dist/types/components/vega-button-group/types.d.ts

@@ -46,25 +46,31 @@ export type ButtonItemsProps = {
 	/**
 	 * Icon name for the button.
 	 */
-	icon: string;
+	'icon': string;
 	/**
 	 * Label text for the button.
 	 */
-	label: string;
+	'label': string;
 	/**
 	 * Size of the button.
 	 */
-	size: VegaButtonGroupSize;
+	'size': VegaButtonGroupSize;
 	/**
 	 * Icon alignment within the button.
 	 */
-	iconAlign: VegaButtonGroupIconAlign;
+	'iconAlign': VegaButtonGroupIconAlign;
 	/**
 	 * Whether the button is disabled.
 	 */
-	disabled: boolean;
+	'disabled': boolean;
+	/**
+	 * Accessible name forwarded to the underlying button when the visible label
+	 * is suppressed (icon-only). Mapped to `aria-label` by the button's
+	 * `AriaAttributesValueMapper`.
+	 */
+	'data-aria-label'?: string;
 	/**
 	 * Ref callback for obtaining the element.
 	 */
-	ref: (node: HTMLElement) => void;
+	'ref': (node: HTMLElement) => void;
 };

package/dist/types/components/vega-dropdown/vega-dropdown.d.ts

@@ -7,7 +7,7 @@ import { VegaDropdownCreateRenderer } from './slimmers/renderers/vega-dropdown-c
 import { VegaDropdownListRenderer } from './slimmers/renderers/vega-dropdown-list-renderer';
 import { VegaDropdownItemLevelRenderer } from './slimmers/renderers/vega-dropdown-item-level-renderer';
 import { VegaDropdownSearchRenderer } from './slimmers/renderers/vega-dropdown-search-renderer';
-import { VegaDropdownKeyboardController } from './slimmers/controllers/vega-dropdown-keyboard-conttroller';
+import { VegaDropdownKeyboardController } from './slimmers/controllers/vega-dropdown-keyboard-controller';
 import { VegaDropdownAppenderController } from './slimmers/controllers/vega-dropdown-appender-controller';
 import { VegaDropdownSearchTriggerEventDetail, VegaDropdownSearchTriggerByType, VegaDropdownSourceItem } from './types';
 import { VegaDropdownGroupLevelRenderer } from './slimmers/renderers/vega-dropdown-group-level-renderer';

package/dist/types/components/vega-field-label/slimmers/renderers/vega-field-label-label-announcement-renderer.d.ts

@@ -1,5 +1,4 @@
 import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
-import { Nullable } from '../../../../types/general';
 export declare class VegaFieldLabelLabelAnnouncementRenderer extends VegaSlimmer {
   private label;
   private isFieldRequired;
@@ -7,15 +6,9 @@ export declare class VegaFieldLabelLabelAnnouncementRenderer extends VegaSlimmer
   private disabled;
   private translationSlimmer;
   /**
-   * Render a label announcement.
+   * Build the visually-hidden state suffix (the part after the label text).
    *
-   * @returns {Nullable<HTMLElement>}
+   * @returns {string} e.g. ", Required, Disabled", or '' when there is no state to announce.
    */
-  render(): Nullable<HTMLElement>;
-  /**
-   * Generate a screen-reader-friendly announcement string that concatenates the label text with the field's required/optional and disabled states.
-   *
-   * @returns {string} The generated announcement string.
-   */
-  private generateAnnouncement;
+  getStateSuffix(): string;
 }

package/dist/types/components/vega-input-select/slimmers/renderers/vega-input-select-dropdown-renderer.d.ts

@@ -30,6 +30,14 @@ export declare class VegaInputSelectDropdownRenderer extends VegaSlimmer {
   render(): HTMLVegaDropdownElement;
   private renderItemsSlot;
   private renderContainer;
+  /**
+   * VD-9605: open/close the dropdown on both Enter and Space, matching native button
+   * semantics. Space is preventDefaulted so activating the trigger does not scroll the page.
+   *
+   * @param {KeyboardEvent} e - keydown event on the select trigger.
+   * @returns {void}
+   */
+  private handleTriggerKeyDown;
   private renderPrefixIcon;
   private renderToggleIcon;
   private renderSelectContainer;

package/dist/types/components/vega-modal/slimmers/controllers/vega-modal-open-state-controller.d.ts

@@ -21,6 +21,23 @@ export declare class VegaModalOpenStateController extends VegaSlimmer {
   protected readonly ariaDialogFocusableTrapSlimmer: AriaDialogFocusableTrapSlimmer;
   private backdropMouseDownOnHost;
   private backdropMouseUpOnHost;
+  /**
+   * Component lifecycle - [connectedCallback]
+   *
+   * Capture-phase Escape listener is registered here (rather than
+   * `componentDidLoad`) so it is re-added whenever the modal element is moved
+   * in the DOM (e.g. RTE's Insert-via-URL modal is moved to `host.parentElement`
+   * before being shown — that triggers disconnect+connect but does not re-fire
+   * `componentDidLoad`).
+   *
+   * Capture-phase Escape listener so ancestor focus-trap containers (e.g. a
+   * Bootstrap modal whose own keydown handler is attached to the modal
+   * element) do not also react to the same Escape press while a vega-modal
+   * is open inside them. Capture phase fires before any descendant bubble
+   * listener; calling `stopPropagation` then prevents those listeners from
+   * running. We only intervene when this is the topmost open vega-modal.
+   */
+  connectedCallback(): void;
   /**
    * Component lifecycle - [disconnectedCallback]
    */
@@ -95,6 +112,22 @@ export declare class VegaModalOpenStateController extends VegaSlimmer {
    * @param {VegaModalOpenStateChangeTrigger} triggerBy - Source that initiated the change.
    */
   changeOpenState(isOpen: boolean, triggerBy: VegaModalOpenStateChangeTrigger): void;
+  /**
+   * Capture-phase document `keydown` listener for Escape. When this modal is
+   * the topmost open vega-modal we close it and stop propagation so that
+   * ancestor focus traps (e.g. a Bootstrap modal which closes itself on
+   * Escape via its own keydown listener attached to the modal element) do
+   * not also react to the same key press and close themselves.
+   *
+   * If an inner overlay (vega-dropdown / vega-popover) already handled this
+   * Escape press, it calls `markOverlayHandledEscape(event)` from its own
+   * capture-phase listener. `isOverlayHandledEscape` detects this so this
+   * modal does not also close — meaning Escape closes only the innermost
+   * overlay.
+   *
+   * @param {KeyboardEvent} event - The keydown event.
+   */
+  private handleEscapeCapture;
   /**
    * Manages the visibility and behavior of a modal by updating various properties
    * and emitting an event.

package/dist/types/components/vega-modal/types.d.ts

@@ -28,4 +28,5 @@ export type VegaModalOpenStateChangeTrigger =
 	| 'method' // The public modal('hide/show') method triggers to close or show modal by user.
 	| 'property' // The `open` property is changed by user.
 	| 'data-target' // The target element clicked has a `data-target='modal'` attribute and open the modal.
-	| 'data-dismiss'; // The target element clicked has a `data-dismiss='modal'` attribute and close the modal.
+	| 'data-dismiss' // The target element clicked has a `data-dismiss='modal'` attribute and close the modal.
+	| 'escape'; // User presses the Escape key while this modal is the topmost open vega-modal.

package/dist/types/components/vega-popover/slimmers/renderers/vega-popover-appender-renderer.d.ts

@@ -16,6 +16,15 @@ export declare class VegaPopoverAppenderRenderer extends VegaSlimmer {
    * @returns {HTMLVegaPopoverContentBoxElement} An HTMLVegaPopoverContentBoxElement is being returned.
    */
   getPopoverContentBox(): HTMLVegaPopoverContentBoxElement;
+  /**
+   * Whether an inner overlay (e.g. an open `vega-input-select`/`vega-dropdown`
+   * or a nested popover) is currently displayed inside this popover's content
+   * box. Such overlays own the Escape key, so the popover must not close while
+   * one of them is open.
+   *
+   * @returns {boolean} True when a visible nested overlay content box exists.
+   */
+  hasOpenNestedOverlay(): boolean;
   /**
    * The `render` function returns a JSX element for a `vega-popover-content-box` component with a ref assigned to `this.popoverContentBox`.
    *

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

@@ -2,6 +2,11 @@ import { VegaRTEColorSchema, VegaRTETextStyleItem, VegaRTEToolbarItem } from '..
 export declare const RTE_DEFAULT_TEXT_COLOR: VegaRTEColorSchema;
 export declare const RTE_TEXT_COLORS: VegaRTEColorSchema[];
 export declare const ZERO_WIDTH_SPACE: string;
+export declare enum RTEUpdateSource {
+  Default = "default",
+  Composition = "composition"
+}
+export declare const RTE_UPDATE_SOURCE_KEY: string;
 export declare const VegaRTEDefaultTextStyleItems: VegaRTETextStyleItem[];
 export declare const VegaRTEPresetToolbarItems: VegaRTEToolbarItem[][];
 /**
@@ -33,3 +38,4 @@ export declare const RTE_PASTE_MODE_DATA_TYPE: string;
  * originated from Microsoft Word.
  */
 export declare const RTE_PASTE_MODE_WORD: string;
+export declare const RTE_WORD_COUNT_KEY: string;

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/commit-value-strategy.d.ts

@@ -0,0 +1,13 @@
+import { CommitValueAction } from '../../actions/commit-value-action';
+import type { VegaRTEContent } from '../../content-state';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Default commit strategy — the candidate becomes the committed value. Rejection
+ * is handled exclusively by interceptors that veto the commit by not executing.
+ */
+export declare class CommitValueStrategy extends ActionHandleStrategy<CommitValueAction, VegaRTEContent, VegaRTEContent> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: CommitValueAction): VegaRTEContent;
+}

package/dist/types/components/vega-rich-text-editor/dto/actions/commit-value-action.d.ts

@@ -0,0 +1,20 @@
+import { Nullable } from '../../../../types/general';
+import type { VegaRTEContent } from '../content-state';
+import { ModifyContentAction } from './modify-content-action.abstract';
+/**
+ * Action type discriminator. Plain string constant — intentionally NOT added to
+ * {@link ModifyContentActionType} enum to keep the commit-validation flow self-contained.
+ */
+export declare const COMMIT_VALUE: string;
+/**
+ * Dispatched before the editor commits a candidate value. The default strategy
+ * commits the candidate as-is; interceptors are the only place a commit is vetoed.
+ */
+export declare class CommitValueAction extends ModifyContentAction {
+  readonly candidate: VegaRTEContent;
+  readonly previous: Nullable<VegaRTEContent>;
+  readonly host: HTMLVegaRichTextEditorElement;
+  isFlushable: boolean;
+  type: string;
+  constructor(candidate: VegaRTEContent, previous: Nullable<VegaRTEContent>, host: HTMLVegaRichTextEditorElement);
+}

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

@@ -104,6 +104,12 @@ export declare abstract class RTEBlock<P = RTEBlockParentType, C = RTEBlockChild
    * @returns {Nullable<RTENode>} The first RTENode or null if no children exist.
    */
   getFirstNode(): Nullable<RTENode>;
+  /**
+   * Get the plain text content of the block, used for character counting.
+   *
+   * @returns {string} The concatenated plain text of all child nodes and blocks.
+   */
+  getPlainText(): string;
   /**
    * Check if the block is a list item block
    *

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

@@ -45,6 +45,10 @@ export declare class RTEListItemBlock extends RTETextBlock {
    * @inheritDoc
    */
   getLastNode(): RTETextNode;
+  /**
+   * @inheritDoc
+   */
+  getPlainText(): string;
   /**
    * Create a new list item block.
    *

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

@@ -83,6 +83,12 @@ export declare class VegaRTEContent {
    * @returns {Nullable<RTENode>} The last node in the content or null if there are no nodes.
    */
   getLastNode(): Nullable<RTENode>;
+  /**
+   * Get the plain text content of the whole document, used for character counting.
+   *
+   * @returns {string} The concatenated plain text of all top-level blocks.
+   */
+  getPlainText(): string;
   /**
    * Convert text to list.
    *

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

@@ -32,6 +32,10 @@ export declare class RTECodeBlockNode extends RTEDecoratorNode<RTECodeBlock> {
    * @returns {VegaRTECodeNode} - An object contains content property.
    */
   toJSON(): VegaRTECodeNode;
+  /**
+   * @inheritDoc
+   */
+  getPlainText(): string;
   /**
    * @inheritDoc
    */

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

@@ -90,6 +90,12 @@ export declare abstract class RTENode<P extends RTEBlock = RTEBlock> {
    * @returns {boolean} - True if the node is a text node, false otherwise.
    */
   isTextNode(): this is RTETextNode;
+  /**
+   * Get the plain text content of the node, used for character counting. Default implementation returns an empty string, subclasses should override this method to provide the actual plain text content.
+   *
+   * @returns {string} The plain text content of the node.
+   */
+  getPlainText(): string;
   /**
    * Get the HTMLElement reference associated with this node.
    *

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

@@ -103,6 +103,10 @@ export declare class RTETextNode extends RTENode<RTETextBlock> {
    * @inheritDoc
    */
   isContentEditable(): boolean;
+  /**
+   * @inheritDoc
+   */
+  getPlainText(): string;
   /**
    * Returns the inline HTML wrapper descriptor at the given depth in the
    * annotation chain. Depth 0 is the outermost wrapper, depth 1 is its child, etc.

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

@@ -114,6 +114,11 @@ export declare abstract class VegaRTEToolbarButtonRenderer {
    * @param {MouseEvent} e The mouse event to prevent default action for.
    */
   protected preventDefault(e: MouseEvent): void;
+  /**
+   * Moves focus to the toolbar button. Targets the inner focusable `<button>`
+   * inside the button's shadow root, falling back to the host element.
+   */
+  protected focusToolbarButton(): void;
   /**
    * Recursively searches for a dropdown list item by its key.
    *

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

@@ -61,4 +61,23 @@ export declare class FindReplaceToolbarButtonRenderer extends VegaRTEToolbarButt
    * Closes the panel popover.
    */
   private closePanel;
+  /**
+   * Decides whether closing the panel should return focus to the toolbar button.
+   *
+   * Focus is restored when the panel is dismissed while focus is still inside it
+   * (Escape key or the Close button) — including the VoiceOver case where the
+   * dialog's `inert` blur has already moved focus to `<body>`. It is not restored
+   * when focus has intentionally moved to another element (Tab out of the panel
+   * or interacting with something else), so we don't yank focus back.
+   *
+   * @returns {boolean} True when focus should return to the toolbar button.
+   */
+  private shouldRestoreFocusToButton;
+  /**
+   * Checks whether an element is inside the panel, crossing shadow boundaries.
+   *
+   * @param {Nullable<HTMLElement>} el - The element to test.
+   * @returns {boolean} True when the element is contained by the panel.
+   */
+  private isElementWithinPanel;
 }

package/dist/types/components/vega-rich-text-editor/extensions/functions/dto/logic-control-node.d.ts

@@ -47,4 +47,8 @@ export declare class RTELogicControlNode extends RTENode {
    * @returns {boolean} - The content editable state of the node.
    */
   isContentEditable(): boolean;
+  /**
+   * @inheritDoc
+   */
+  getPlainText(): string;
 }

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

@@ -1,5 +1,5 @@
 import { VegaRTELineHeightOption } from '../type';
-import { VegaRTECreateElementFunction, VegaRTERenderResult, VegaRTEToolbarRenderContext } from '../../interface';
+import { RTEDropdownListItem, VegaRTECreateElementFunction, VegaRTERenderResult, VegaRTEToolbarRenderContext } from '../../interface';
 import { VegaRTEToolbarButtonRenderer } from '../base-toolbar-button-renderer';
 /**
  * Renderer for the line-height toolbar button in the Vega Rich Text Editor.
@@ -11,6 +11,19 @@ export declare class RTELineHeightToolbarButtonRenderer extends VegaRTEToolbarBu
    * @inheritDoc
    */
   render(createElement: VegaRTECreateElementFunction, editorContext: VegaRTEToolbarRenderContext): VegaRTERenderResult;
+  /**
+   * Renders each line-height option with its label as light-DOM children rather than the
+   * `label` prop. This gives the focusable menuitem a light-DOM text anchor so Safari
+   * VoiceOver's reading cursor follows focus into the item (Ctrl+Opt+Right walks item→item
+   * instead of escaping to the next toolbar button).
+   *
+   * The label is wrapped in a `<span>` (not a bare text node) so a click targeting the label
+   * lands on a slotted element that composes into the item's shadow `<li>`; a bare text node
+   * resolves to the `vega-dropdown-item` host, whose click never reaches the shadow handler.
+   *
+   * @inheritDoc
+   */
+  protected renderDropdownItem(h: VegaRTECreateElementFunction, item: RTEDropdownListItem, editorContext: VegaRTEToolbarRenderContext): VegaRTERenderResult;
   /**
    * @inheritDoc
    */

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

@@ -1,4 +1,4 @@
-import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
 import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
 import { RTETableCaptionBlock } from '../dto/table-caption-block';
 export declare const TABLE_CAPTION_PLACEHOLDER_TEXT: string;
@@ -9,5 +9,5 @@ export declare class RTETableCaptionRenderer extends VegaRTEExtensionRenderer {
   /**
    * @inheritDoc
    */
-  doRender(h: VegaRTECreateElementFunction, renderData: RTETableCaptionBlock): VegaRTERenderResult;
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableCaptionBlock, rteContext: RTERenderContext): VegaRTERenderResult;
 }

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-dynamic-popover-renderer.d.ts

@@ -32,8 +32,10 @@ export declare class TableDynamicPopoverRenderer extends TablePopoverBaseRendere
    *
    * @param {string} type - The table setting type determining which
    *  content variant to display (for example, table properties or cell properties).
+   * @param {Nullable<HTMLElement>} returnCell - The cell to move focus into the dialog for and
+   *  return focus to if the dialog is dismissed with Escape (set for keyboard/screen-reader users).
    */
-  show(type: string): Promise<void>;
+  show(type: string, returnCell?: Nullable<HTMLElement>): Promise<void>;
   /**
    * hide the popover.
    */
@@ -51,6 +53,21 @@ export declare class TableDynamicPopoverRenderer extends TablePopoverBaseRendere
    * @returns {Nullable<HTMLElement>} The constructed popover element.
    */
   render(): Nullable<HTMLElement>;
+  /**
+   * Whether the given event originated inside the properties dialog subtree (either the table or the
+   * cell properties form).
+   *
+   * @param {Event} event - The event to test.
+   * @returns {boolean} `true` when an active form is rendered and the event's composed path includes it.
+   */
+  protected isEventWithinPopover(event: Event): boolean;
+  /**
+   * Resolves the `.rich-text-content` editor root from the current table ref so the content can be
+   * made inert while the properties dialog holds keyboard/VoiceOver focus.
+   *
+   * @returns {Nullable<HTMLElement>} The editor content element, or `null` when it cannot be resolved.
+   */
+  protected getInertContentTarget(): Nullable<HTMLElement>;
   /**
    * Updates the visibility of the pre-rendered content blocks based on type.
    *
@@ -67,6 +84,19 @@ export declare class TableDynamicPopoverRenderer extends TablePopoverBaseRendere
    * Stores the current focus node before properties update action.
    */
   private storeCurrentFocusNode;
+  /**
+   * Moves focus to the first focusable control in the active properties form so keyboard and
+   * screen-reader users land inside the dialog when it opens. The first form field is the Border
+   * Style select; its focusable trigger is the `.vega-input-select-container` element.
+   *
+   * @param {string} type - The table setting type that determines which form is visible.
+   */
+  private focusFirstFormField;
+  /**
+   * When the properties dialog hides after an Escape press, returns focus (and the caret) to the
+   * table cell that had focus before the dialog was opened via the setting toolbar.
+   */
+  private handleDialogHide;
   /**
    * Create and position an invisible anchor element whose position and size are identical to the geometry of the current multi-cell selection.
    * This anchor element will then be used as the target of the popup, so that the popup appears near the entire selection area.

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

@@ -3,9 +3,25 @@ import { RTERenderContext, VegaRTEToolbarRenderContext } from '../../../interfac
 import { RTETableExtensionContext } from '../table-extension';
 /**
  * Base renderer for table-related popovers, providing common functionalities such as accessing the table extension context.
+ *
+ * Popovers that move keyboard/VoiceOver focus into themselves (the setting toolbar and the
+ * properties dialog) share the same focus-restoration machinery: they make the editor content
+ * `inert` while open, track Escape presses at the document level, and return focus (and the caret)
+ * to the originating cell when an Escape dismisses the popover. That behavior lives here so the two
+ * renderers do not each carry a copy; subclasses only supply the two pieces that differ — how to
+ * resolve the editor content root ({@link getInertContentTarget}) and how to tell whether an event
+ * originated inside their own popover subtree ({@link isEventWithinPopover}).
  */
 export declare class TablePopoverBaseRenderer {
   protected renderContext: Nullable<RTERenderContext | VegaRTEToolbarRenderContext>;
+  /** The editor content element made inert while the popover holds focus, cached so it can be restored. */
+  protected inertedContentEl: Nullable<HTMLElement>;
+  /** The table cell to return focus to when the popover is dismissed via Escape. */
+  protected returnFocusCell: Nullable<HTMLElement>;
+  /** Tracks whether Escape was pressed while the popover was open. */
+  protected escapePressed: boolean;
+  /** Document the Escape tracker keydown listener is bound to, for later removal. */
+  protected keydownListenerDocument: Nullable<Document>;
   constructor(renderContext: RTERenderContext | VegaRTEToolbarRenderContext);
   /**
    * Retrieves the table extension context associated with the current render context.
@@ -13,4 +29,79 @@ export declare class TablePopoverBaseRenderer {
    * @returns {Nullable<RTETableExtensionContext>} The table extension context if available, otherwise null.
    */
   protected getTableExtensionContext(): Nullable<RTETableExtensionContext>;
+  /**
+   * Begins tracking so a later Escape can return focus to `returnCell`. Records the cell and clears
+   * any stale Escape observed before the popover was opened.
+   *
+   * @param {Nullable<HTMLElement>} returnCell - The cell to return focus to if the popover is dismissed with Escape.
+   */
+  protected beginReturnFocusTracking(returnCell: Nullable<HTMLElement>): void;
+  /**
+   * Registers the document-level (capture phase) Escape tracker. The popover renders in a portal, so
+   * its Escape does not bubble back to the table; observing on the document lets us know when to
+   * return focus to the cell.
+   *
+   * @param {Document} doc - The document to bind the keydown listener to.
+   */
+  protected attachEscapeTracker(doc: Document): void;
+  /**
+   * Removes the document-level Escape tracker if one was registered.
+   */
+  protected detachEscapeTracker(): void;
+  /**
+   * Tracks Escape key presses that originate inside the popover so focus can be returned to the
+   * originating cell when that Escape dismisses the popover. vega-popover's own Escape handler hides
+   * the popover without restoring focus, so the restore is coordinated here.
+   *
+   * The listener is bound at the document level (the popover renders in a portal, so its Escape does
+   * not bubble back to the table), so scope it to the popover subtree via {@link isEventWithinPopover}:
+   * a stray Escape elsewhere must not arm the restore and hijack focus on a later non-Escape dismissal
+   * (e.g. click-outside).
+   *
+   * @param {KeyboardEvent} event - The keydown event.
+   */
+  protected handleDocumentKeydown: (event: KeyboardEvent) => void;
+  /**
+   * Whether the given event originated inside this popover's subtree. Subclasses override this to
+   * match their own portal-rendered content; the base returns `false` so renderers that do not move
+   * focus never arm the restore.
+   *
+   * @param {Event} _event - The event to test.
+   * @returns {boolean} `true` when the event originated inside the popover subtree.
+   */
+  protected isEventWithinPopover(_event: Event): boolean;
+  /**
+   * When the popover hides after an Escape press, returns focus (and the caret) to the table cell
+   * that had focus before the popover was opened.
+   *
+   * vegaPopoverHide fires synchronously from the popover's own Escape handler, before the
+   * document-capture keydown observes the key and before the popover settles focus on `<body>`.
+   * Defer past that so the flag is set and this focus restore wins.
+   */
+  protected restoreFocusOnEscapeHide(): void;
+  /**
+   * Focuses the given table cell and collapses the caret at its start.
+   *
+   * @param {HTMLElement} cell - The table cell to focus.
+   */
+  protected restoreFocusToCell(cell: HTMLElement): void;
+  /**
+   * Resolves the `.rich-text-content` editor root to toggle `inert` on while the popover holds focus.
+   * Subclasses override this because they reach the content from different anchors (the toolbar's
+   * target vs. the current table ref); the base returns `null` so renderers that do not use inert are
+   * unaffected.
+   *
+   * @returns {Nullable<HTMLElement>} The editor content element, or `null` when it cannot be resolved.
+   */
+  protected getInertContentTarget(): Nullable<HTMLElement>;
+  /**
+   * Toggles `inert` on the editor content region while the popover holds keyboard/VoiceOver focus.
+   * Safari VoiceOver keeps its reading cursor anchored to the cell caret and does not follow the
+   * programmatic focus moved into the popover; making the editor content inert removes that text
+   * context so the VoiceOver cursor lands inside the popover. The popover is a body-level portal, so it
+   * is not a descendant of the inert content and stays interactive.
+   *
+   * @param {boolean} inert - Whether the editor content should be inert.
+   */
+  protected setEditorContentInert(inert: boolean): void;
 }

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

@@ -24,9 +24,55 @@ export declare class RTETableBlockRenderer extends VegaRTEExtensionRenderer {
    * @param {VegaRTECreateElementFunction} h - The create element function.
    * @param {RTETableBlock} renderData - The table block to render.
    * @param {(ref: HTMLElement) => HTMLElement} setTableRef - Set table ref to tableRef
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
    * @returns {VegaRTERenderResult} - The rendered table element.
    */
   private renderTable;
+  /**
+   * Handles activation of the table itself (e.g. VoiceOver Ctrl+Option+Space, which dispatches a
+   * click on the focused table) by moving focus into the first cell so the user can start editing.
+   *
+   * @param {MouseEvent} event - The click event dispatched on the table.
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   */
+  private handleTableActivate;
+  /**
+   * Handles table-scoped keyboard shortcuts while focus is inside the table:
+   * - Alt+F10 opens the table setting toolbar (re-targeting and showing it when needed) and moves
+   *   focus to it (the common "focus the contextual toolbar" shortcut), so keyboard/screen-reader
+   *   users can reach the toolbar buttons even when it is currently closed.
+   * - Escape moves focus back onto the table, so the caret leaves the cell (its focus highlight
+   *   is cleared), the contextual setting toolbar is dismissed, and screen readers announce the
+   *   table again.
+   *
+   * @param {KeyboardEvent} event - The keydown event.
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   * @param {RTETableBlock} renderData - The table block being rendered.
+   */
+  private handleTableKeyDown;
+  /**
+   * Moves focus (and the caret) into the first cell of the table.
+   *
+   * @param {HTMLElement} tableRef - The table element.
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   */
+  private focusFirstCell;
+  /**
+   * Moves focus onto the table element and clears any cell caret and selection highlight.
+   *
+   * @param {HTMLElement} tableRef - The table element.
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   */
+  private focusTable;
+  /**
+   * Resolves the editor selection, preferring the shadow-aware selection from the extension
+   * context and falling back to the table's owning document.
+   *
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   * @param {HTMLElement} tableRef - The table element.
+   * @returns {Nullable<Selection>} - The resolved selection, or null when unavailable.
+   */
+  private getSelection;
   /**
    * Handles the removal of the table block.
    *