@globalpayments/vega 2.99.0 → 2.100.0

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

@@ -1,3 +1,4 @@
+import { Nullable } from '../../../../../types/general';
 import { RTETableBlock } from '../dto/table-block';
 import { TablePopoverBaseRenderer } from './table-popover-base-renderer';
 import { RTERenderContext } from '../../../interface';
@@ -28,14 +29,58 @@ export declare class TableSettingPopoverRenderer extends TablePopoverBaseRendere
    * Sync the selected cells from the table selection to the table setting component.
    */
   syncSelectedCells: () => void;
+  /**
+   * Hides the table setting toolbar and its dynamic popover. Used when focus leaves the table (e.g.
+   * Escape moves focus from a cell back onto the table) so the contextual toolbar does not linger.
+   */
+  hide: () => void;
+  /**
+   * Opens the table setting toolbar for keyboard/screen-reader users and moves focus to its first
+   * enabled button. Used by the Alt+F10 shortcut so the toolbar can be reached from inside a cell
+   * even when it is currently closed: it re-targets and shows the popover (the same path as a table
+   * click) before deferring focus to the first enabled button.
+   *
+   * @param {RTETableBlock} tableBlock - The table's block data.
+   * @param {() => HTMLElement} getTableRef - Getter for the table's DOM element.
+   * @param {Nullable<HTMLElement>} returnCell - The cell to return focus to if the toolbar is dismissed with Escape.
+   */
+  openSettingToolbarForKeyboard: (tableBlock: RTETableBlock, getTableRef: () => HTMLElement, returnCell?: Nullable<HTMLElement>) => void;
+  /**
+   * Moves focus to the first enabled button in the table setting toolbar. Used by the Alt+F10
+   * shortcut so keyboard and screen-reader users can reach the toolbar from inside the table.
+   *
+   * @param {Nullable<HTMLElement>} returnCell - The cell to return focus to if the toolbar is dismissed with Escape.
+   */
+  focusFirstSettingButton: (returnCell?: Nullable<HTMLElement>) => void;
   /**
    * Builds the popover DOM and appends it to the RTE host. Idempotent: subsequent calls are no-ops.
    */
   render(): void;
+  /**
+   * Whether the given event originated inside the setting toolbar subtree.
+   *
+   * @param {Event} event - The event to test.
+   * @returns {boolean} `true` when the toolbar is rendered and the event's composed path includes it.
+   */
+  protected isEventWithinPopover(event: Event): boolean;
+  /**
+   * Resolves the `.rich-text-content` editor root from the setting toolbar's target so the content
+   * can be made inert while the toolbar holds keyboard/VoiceOver focus.
+   *
+   * @returns {Nullable<HTMLElement>} The editor content element, or `null` when it cannot be resolved.
+   */
+  protected getInertContentTarget(): Nullable<HTMLElement>;
   /**
    * Updates the table setting component caption state to match the current table data.
    */
   private updateTableSettingCaption;
+  /**
+   * When the caption is toggled on, moves keyboard/VoiceOver focus and the caret into the caption so
+   * the user lands in it to start typing. The setting toolbar is opened as inert-guarded for
+   * keyboard/screen-reader users, so lift that guard first; the caption is re-rendered by the toggle,
+   * so defer the focus to the next tick when the `<caption>` element exists.
+   */
+  private moveFocusToCaption;
   /**
    * Re-targets the shared popovers to the given table.
    *
@@ -53,6 +98,19 @@ export declare class TableSettingPopoverRenderer extends TablePopoverBaseRendere
    * Handles the popover show event to sync the selected table cells to the table setting component.
    */
   private handleTableSettingPopoverShow;
+  /**
+   * When the setting popover hides after an Escape press, returns focus (and the caret) to the
+   * table cell that had focus before the toolbar was reached via Alt+F10.
+   */
+  private handleTableSettingPopoverHide;
+  /**
+   * `vega-popover-content-box` renders `role="dialog"` + `aria-modal="true"`, which on WebKit
+   * VoiceOver confines the reading cursor to the popover. Keep those semantics so Ctrl+Opt+Arrow
+   * cannot walk the VoiceOver cursor out of the toolbar past the last button (VoiceOver swallows
+   * those keys, so this cannot be trapped in JS), and give the dialog an accessible name so it
+   * announces "Table tools" on entry.
+   */
+  private labelSettingDialog;
   /**
    * Collects and returns the currently selected table cells.
    *

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

@@ -111,6 +111,14 @@ export declare class RTETableSelection {
    * Handle selection change events from the document for the cell click selection.
    */
   private handleSelectionChange;
+  /**
+   * Resolve the single table cell that contains the given selection node. Used as a fallback when a
+   * collapsed caret does not intersect any text node (see handleSelectionChange).
+   *
+   * @param {Node} node - The selection's common ancestor container.
+   * @returns {RTETableCellBlock[]} The containing cell block, or an empty list when none is found.
+   */
+  private resolveCaretCell;
   /**
    * Recursively filter and collect selected table cell blocks within the given node.
    *

package/dist/types/components/vega-rich-text-editor/extensions/table/vega-rich-text-table-properties/slimmers/renderers/vega-rich-text-table-properties-basic-form-field-renderer.abstract.d.ts

@@ -7,6 +7,7 @@ export declare abstract class VegaRichTextTablePropertiesBaseFormFieldRenderer e
   static TABLE_BORDER_STYLES: SelectSourceItem[];
   protected controller: VegaRichTextTableProperties['controller'];
   protected defaultValue: VegaRichTextTableProperties['defaultValue'];
+  protected translationSlimmer: VegaRichTextTableProperties['translationSlimmer'];
   protected renderer: VegaRichTextTableProperties['renderer'];
   protected styleMap: VegaRichTextTableProperties['styleMap'];
   protected vegaChange: VegaRichTextTableProperties['vegaChange'];
@@ -34,7 +35,7 @@ export declare abstract class VegaRichTextTablePropertiesBaseFormFieldRenderer e
    * @returns { HTMLElement } The dimension fields element.
    */
   protected renderDimensionFields(withPadding?: boolean): HTMLElement;
-  protected renderAlignmentField(alignmentList: string[], iconPrefix: string, formFieldName: string): HTMLElement;
+  protected renderAlignmentField(alignmentList: string[], iconPrefix: string, formFieldName: string, ariaLabelMap: Record<string, string>): HTMLElement;
   /**
    * Render save and cancel action buttons.
    *

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

@@ -9,6 +9,7 @@ import { TableColorController } from './slimmers/controllers/vega-rich-text-tabl
 import { VegaRichTextTablePropertiesFormFieldRenderer } from './slimmers/renderers/vega-rich-text-table-properties-form-field-renderer';
 import { VegaRichTextCellPropertiesFormFieldRenderer } from './slimmers/renderers/vega-rich-text-cell-properties-form-field-renderer';
 import { DarkModeStateControllerSlimmer } from '../../../../../helpers/slimmers/dark-mode-state-controller-slimmer';
+import { AriaAttributesValueMapper } from '../../../../../helpers/slimmers/mutation-observer/aria-attributes-value-mapper';
 /**
  * @vegaVersion 2.79.0
  */
@@ -21,6 +22,7 @@ export declare class VegaRichTextTableProperties {
   protected readonly cellFormRenderer: VegaRichTextCellPropertiesFormFieldRenderer;
   protected readonly controller: TableColorController;
   protected darkModeStateSlimmer: DarkModeStateControllerSlimmer;
+  protected ariaAttributesValueMapper: AriaAttributesValueMapper;
   protected changeEventPreventSlimmer: ChildNodesEventPreventSlimmer;
   host: HTMLVegaRichTextTablePropertiesElement;
   isInDarkMode: boolean;

package/dist/types/components/vega-rich-text-editor/extensions/table/vega-rich-text-table-setting/slimmers/renderers/row-button-slimmer.d.ts

@@ -1,8 +1,10 @@
 import { TableSettingButtonSlimmer } from './table-setting-button-slimmer.abstract';
+import { VegaRichTextTableSetting } from '../../vega-rich-text-table-setting';
 /**
  * Slimmer dedicated to building the row button.
  */
 export declare class RowButtonSlimmer extends TableSettingButtonSlimmer {
+  isRowDropdownOpen: VegaRichTextTableSetting['isRowDropdownOpen'];
   constructor();
   protected renderBtnWrapper(renderBtn: () => HTMLElement): HTMLElement;
   protected isDisabled(): boolean;
@@ -15,6 +17,7 @@ export declare class RowButtonSlimmer extends TableSettingButtonSlimmer {
    */
   private renderActionList;
   private handleDropdownItemClick;
+  private handleDropdownVisibilityChange;
   /**
    * Check if all selected rows are header rows.
    *

package/dist/types/components/vega-rich-text-editor/extensions/table/vega-rich-text-table-setting/slimmers/renderers/table-setting-button-slimmer.abstract.d.ts

@@ -4,6 +4,7 @@ export declare type RTETableSettingButtonProps = {
   icon: string;
   title: string;
   showArrowIcon?: boolean;
+  ariaLabel: string;
 };
 export declare abstract class TableSettingButtonSlimmer extends VegaSlimmer {
   protected hasCaption: VegaRichTextTableSetting['hasCaption'];
@@ -12,7 +13,8 @@ export declare abstract class TableSettingButtonSlimmer extends VegaSlimmer {
   protected readonly icon: RTETableSettingButtonProps['icon'];
   private readonly title;
   private readonly showArrowIcon;
-  protected constructor({ icon, title, showArrowIcon }: RTETableSettingButtonProps);
+  private readonly ariaLabel;
+  protected constructor({ icon, title, showArrowIcon, ariaLabel }: RTETableSettingButtonProps);
   render(): HTMLElement;
   protected emitClickEvent(setting: Array<string>): void;
   /**

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

@@ -28,6 +28,7 @@ export declare class VegaRichTextTableSetting {
   protected readonly mergeCellsButtonSlimmer: MergeCellsButtonSlimmer;
   host: HTMLVegaRichTextTableSettingElement;
   isColumnDropdownOpen: boolean;
+  isRowDropdownOpen: boolean;
   isMergeCellsDropdownOpen: boolean;
   /**
    * Indicates whether the current table already has a caption.

package/dist/types/components/vega-rich-text-editor/extensions/word-count/action-handler-interceptors/prevent-hard-limit-exceed-interceptor.d.ts

@@ -0,0 +1,38 @@
+import { ActionHandlerInterceptor } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
+import { CommitValueAction } from '../../../dto/actions/commit-value-action';
+import type { VegaRTEContent } from '../../../dto/content-state';
+/**
+ * Vetoes a commit that would push the character count past the hard limit, while
+ * still allowing deletions and formatting that keep or reduce the count.
+ */
+export declare class PreventHardLimitExceedInterceptor extends ActionHandlerInterceptor<CommitValueAction, VegaRTEContent> {
+  /**
+   * Intercept when the candidate exceeds the configured maximum. Hard-limit
+   * commits are vetoed only when they increase the count.
+   *
+   * @param {CommitValueAction} action - the commit action carrying the candidate and previous values
+   * @returns {boolean} - whether the commit should be vetoed
+   */
+  canIntercept(action: CommitValueAction): boolean;
+  /**
+   * Not invoke the origin action handle to veto the commit that would push the character count past the hard limit.
+   */
+  intercept(): void;
+  /**
+   * Notify the consumer when the candidate exceeds the configured character limit.
+   * The previous content is empty when hard limit is not enabled for the performance optimization.
+   *
+   * @param {string} nextContent - the candidate content string
+   * @param {string} prevContent - the previous content string
+   * @param {VegaRTEWordCountExtension} extension - the configured word count extension
+   * @param {CommitValueAction} action - the commit action carrying the candidate value
+   */
+  private notifyCharsLimitExceeded;
+  /**
+   * Check if the given extension is a word count extension.
+   *
+   * @param {VegaRTEExtension} extension - the extension to check
+   * @returns {boolean} - whether the extension is a word count extension
+   */
+  private isWordCountExtension;
+}

package/dist/types/components/vega-rich-text-editor/extensions/word-count/type.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Configurable options for the word count extension.
+ */
+export declare type VegaRTEWordCountConfig = {
+  /**
+   * Whether to display the character count UI in the editor footer.
+   */
+  showCharCount?: boolean;
+  /**
+   * Whether to count inline line breaks (soft breaks) as characters.
+   * Defaults to `false` to match the common editor behavior of not counting
+   * line breaks.
+   */
+  countInlineBreak?: boolean;
+  /**
+   * The maximum number of characters allowed in the editor content.
+   */
+  maxChars?: number;
+  /**
+   * Whether to enforce the maximum character limit by preventing further input.
+   * Defaults to `false`, which allows users to exceed the limit but still displays the count.
+   */
+  hardLimit?: boolean;
+  /**
+   * Callback fired when content exceeds the configured max character limit.
+   */
+  onCharsLimitExceeded?: (host: HTMLVegaRichTextEditorElement, maxChars: number) => void;
+};
+/**
+ * The data produced by the word count extension for a given plain text input.
+ */
+export declare type VegaRTEWordCountData = {
+  /**
+   * The number of characters in the editor content.
+   */
+  count: number;
+  /**
+   * The maximum number of characters allowed in the editor content which user set.
+   */
+  maxChars?: number;
+  /**
+   * Whether the maximum character limit is enforced by preventing further input.
+   */
+  hardLimit: boolean;
+};
+export declare type ResolvedRTEWordCountConfig = Required<Omit<VegaRTEWordCountConfig, 'maxChars' | 'onCharsLimitExceeded'>> & Pick<VegaRTEWordCountConfig, 'maxChars' | 'onCharsLimitExceeded'>;

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

@@ -0,0 +1,38 @@
+import { VegaRTEExtension } from '../extension.abstract';
+import { VegaRTEContent } from '../../dto/content-state';
+import { ResolvedRTEWordCountConfig, VegaRTEWordCountConfig, VegaRTEWordCountData } from './type';
+/**
+ * Default configuration applied when a word count option is not provided.
+ */
+export declare const DEFAULT_WORD_COUNT_CONFIG: ResolvedRTEWordCountConfig;
+/**
+ * Rich Text Editor extension that provides character counting.
+ */
+export declare class VegaRTEWordCountExtension extends VegaRTEExtension {
+  /**
+   * Runtime discriminator used by the core to identify this extension.
+   */
+  readonly type: string;
+  private readonly config;
+  constructor(config?: VegaRTEWordCountConfig);
+  /**
+   * Get the extension configuration.
+   *
+   * @returns {ResolvedRTEWordCountConfig} The word count configuration.
+   */
+  getConfig(): ResolvedRTEWordCountConfig;
+  /**
+   * Compute the character count data for the given editor content.
+   *
+   * @param {VegaRTEContent} value - The editor content.
+   * @returns {VegaRTEWordCountData} The computed character count data.
+   */
+  getData(value: VegaRTEContent): VegaRTEWordCountData;
+  /**
+   * Get the character count for the given content string.
+   *
+   * @param {string} content - The content string.
+   * @returns {number} The character count.
+   */
+  calculateTextCount(content: string): number;
+}

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

@@ -34,6 +34,12 @@ export type ToolbarButtonConfig = {
 	 * Tooltip configuration for the button.
 	 */
 	tooltip: Partial<Pick<HTMLVegaTooltipElement, 'text'>>;
+	/**
+	 * Accessible name applied as `aria-label` on the underlying toolbar button.
+	 * Optional — when omitted, the button falls back to `tooltip.text` so icon-only
+	 * toolbar buttons still expose a meaningful name to screen readers.
+	 */
+	ariaLabel?: string;
 	/**
 	 * Whether to focus the content when clicked
 	 */
@@ -844,6 +850,12 @@ export type RTEToolbarButtonProps = {
 	 * When provided, the button will be wrapped in a vega-tooltip.
 	 */
 	tooltip?: Partial<Pick<HTMLVegaTooltipElement, 'text'>>;
+	/**
+	 * Accessible name applied as `aria-label` on the underlying toolbar button.
+	 * When omitted, falls back to `label` so icon-only buttons still expose a
+	 * meaningful name to screen readers.
+	 */
+	ariaLabel?: string;
 };
 
 /**

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

@@ -29,6 +29,7 @@ export { VegaRTEPasteExtension } from './extensions/paste/paste-extension';
 export { VegaRTECopyExtension } from './extensions/copy/copy-extension';
 export { VegaRTECutExtension } from './extensions/cut/cut-extension';
 export { VegaRTEImageExtension } from './extensions/image/image-extension';
+export { VegaRTEWordCountExtension } from './extensions/word-count/word-count-extension';
 export { ModifyContentAction, ModifyContentActionType } from './dto/actions/modify-content-action.abstract';
 export { AppendChildrenAction } from './dto/actions/append-child-nodes-action';
 export { RemoveChildrenAction } from './dto/actions/remove-child-action';

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

@@ -1,6 +1,7 @@
 import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
 import { VegaRichTextEditor } from '../../vega-rich-text-editor';
 import { VegaRTEContent } from '../../dto/content-state';
+import { RTEUpdateSource } from '../../constants/constant';
 /**
  * The value controller is responsible for updating the value of the rich text editor.
  */
@@ -12,8 +13,11 @@ export declare class ValueController extends VegaSlimmer {
   valueController: VegaRichTextEditor['valueController'];
   historyController: VegaRichTextEditor['historyController'];
   selectionController: VegaRichTextEditor['selectionController'];
+  wordCountController: VegaRichTextEditor['wordCountController'];
+  vegaRichTextEditorRenderer: VegaRichTextEditor['vegaRichTextEditorRenderer'];
   sourceEditConfig: VegaRichTextEditor['sourceEditConfig'];
   private flushChangeObserver;
+  private committedSnapshot;
   /**
    * Component lifecycle - [connectedCallback]{@link VegaRichTextEditor.connectedCallback}
    */
@@ -30,13 +34,19 @@ export declare class ValueController extends VegaSlimmer {
    * Watches the value of the editor and updates the internal value.
    */
   watchValueUpdate(): void;
+  /**
+   * Seeds the rollback snapshot from the current value while a commit interceptor is active.
+   * Runs on load and on extension changes so runtime re-registration stays protected.
+   */
+  seedCommittedSnapshot(): void;
   /**
    * Updates the value of the editor and restore the selection.
    *
    * @param {VegaRTEContent} newValue The new value to set.
    * @param {boolean} recordHistory - Whether to record the change in history.
+   * @param {RTEUpdateSource} updateSource - The source of the update, defaulting to 'default'.
    */
-  flushChanges(newValue: VegaRTEContent, recordHistory?: boolean): Promise<void>;
+  flushChanges(newValue: VegaRTEContent, recordHistory?: boolean, updateSource?: RTEUpdateSource): Promise<void>;
   /**
    * Determines whether the observer should accept changes.
    *

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

@@ -0,0 +1,40 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaRichTextEditor } from '../../vega-rich-text-editor';
+import { Nullable } from '../../../../types/general';
+import type { VegaRTEWordCountData } from '../../extensions/word-count/type';
+/**
+ * Bridges the word count extension to the editor component so the footer UI can
+ * read whether the character count should be shown and its current value.
+ */
+export declare class WordCountController extends VegaSlimmer {
+  protected extensions: VegaRichTextEditor['extensions'];
+  protected host: HTMLVegaRichTextEditorElement;
+  private cachedValue;
+  private cachedConfig;
+  private cachedData;
+  /**
+   * Whether the character count UI should be rendered.
+   *
+   * @returns {boolean} True when a word count extension requests the UI.
+   */
+  shouldShowUI(): boolean;
+  /**
+   * Compute the current character count data from the editor content.
+   *
+   * @returns {Nullable<VegaRTEWordCountData>} The count data or null when no word count extension is registered.
+   */
+  getData(): Nullable<VegaRTEWordCountData>;
+  /**
+   * Whether the word count extension gates commits with a hard character limit.
+   *
+   * @returns {boolean} True when a hard limit with a max character count is configured for this host.
+   */
+  hasWordCountHardLimit(): boolean;
+  /**
+   * Locate the word count extension by its runtime `type` discriminator.
+   * Use this way instead of instanceof to avoid direct dependency on the extension class.
+   *
+   * @returns {Nullable<VegaRTEWordCountExtension>} The word count extension or null.
+   */
+  private findWordCountExtension;
+}

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

@@ -8,10 +8,24 @@ export declare class LinkToolbarButtonSlimmer extends VisualModeToolbarButtonSli
   private linkEditorRef;
   private currentSelectedText;
   private linkBtnWrapperRef;
+  private escapePressedDuringPopover;
+  private documentKeydownRegistered;
+  /**
+   * Component lifecycle - [disconnectedCallback]
+   *
+   * Removes the document-level Escape listener registered in the wrapper
+   * ref callback so the slimmer instance is not retained by document after
+   * the rich-text editor is destroyed.
+   */
+  disconnectedCallback(): void;
   constructor();
   protected renderBtnWrapper(renderBtn: (toolbarInternalButton?: ToolbarInternalButtonConfig) => HTMLElement): HTMLElement;
   protected isSelected(): boolean;
   protected isDisabled(): boolean;
   protected onClick(): void;
   private handleLinkEditorChange;
+  private handleWrapperClickCapture;
+  private handlePopoverShow;
+  private handleDocumentKeydown;
+  private handlePopoverHide;
 }

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

@@ -2,7 +2,6 @@ import { ToolbarButtonSlimmer } from './toolbar-button-slimmer.abstract';
 import { VegaRichTextEditor } from '../../../vega-rich-text-editor';
 export declare class SourceEditToolbarButtonSlimmer extends ToolbarButtonSlimmer {
   sourceView: VegaRichTextEditor['sourceView'];
-  selectionController: VegaRichTextEditor['selectionController'];
   valueController: VegaRichTextEditor['valueController'];
   richTextEditorSourceViewRenderer: VegaRichTextEditor['richTextEditorSourceViewRenderer'];
   sourceEditConfig: VegaRichTextEditor['sourceEditConfig'];
@@ -10,6 +9,9 @@ export declare class SourceEditToolbarButtonSlimmer extends ToolbarButtonSlimmer
   value: VegaRichTextEditor['value'];
   constructor();
   protected onClick(): Promise<void>;
+  protected preventLostFocus(): {
+    onMouseDown?: (e: Event) => void;
+  };
   protected isSelected(): boolean;
   protected isDisabled(): boolean;
   private saveSourceCode;

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

@@ -13,8 +13,9 @@ export declare abstract class ToolbarButtonSlimmer extends VegaSlimmer {
   protected readonly disabled: VegaRichTextEditor['disabled'];
   private icon;
   private readonly tooltip;
+  private readonly ariaLabel;
   private readonly autoFocusOnClick;
-  protected constructor({ icon, tooltip, autoFocusOnClick }: ToolbarButtonConfig);
+  protected constructor({ icon, tooltip, ariaLabel, autoFocusOnClick }: ToolbarButtonConfig);
   setIcon(icon: string): void;
   /**
    * Whether the button is hidden or not.
@@ -41,7 +42,7 @@ export declare abstract class ToolbarButtonSlimmer extends VegaSlimmer {
    */
   protected isDisabled(): boolean;
   protected preventLostFocus(): {
-    onMouseDown: (e: Event) => void;
+    onMouseDown?: (e: Event) => void;
   };
   private renderBtn;
   /**

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

@@ -17,6 +17,7 @@ export declare class VegaRichTextEditorRenderer extends VegaSlimmer {
   sourceEditConfig: VegaRichTextEditor['sourceEditConfig'];
   allowSourceEdit: VegaRichTextEditor['allowSourceEdit'];
   extensions: VegaRichTextEditor['extensions'];
+  wordCountController: VegaRichTextEditor['wordCountController'];
   richTextEditorSourceViewRenderer: VegaRichTextEditor['richTextEditorSourceViewRenderer'];
   private richTextContainerRef;
   private richTextContentRef;
@@ -49,6 +50,17 @@ export declare class VegaRichTextEditorRenderer extends VegaSlimmer {
    * @returns {Nullable<HTMLDivElement>} The div element which has property contenteditable
    */
   getRTEEditableElementRef(): Nullable<HTMLDivElement>;
+  /**
+   * Re-injects the zero-width space placeholder into empty text spans.
+   * When a commit is rejected and the model rolls back unchanged, the framework
+   * short-circuits the text diff and leaves the span empty, collapsing the line
+   * height, so the placeholder is restored here.
+   */
+  restoreEmptyTextPlaceholders(): void;
+  /**
+   * Forces a re-render of the rich text content component, which is useful when the content has changed but the framework has not detected it.
+   */
+  forceContentRepaint(): void;
   render(): VegaRichTextEditor;
   private renderRichTextEditor;
   private renderLabel;

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

@@ -5,6 +5,7 @@ import { EventEmitSlimmerBase } from '../../../helpers/event-manager/slimmers/ev
 import { VegaRichTextEditorToolbarButtonRenderer } from './slimmers/renderers/vega-rich-text-editor-toolbar-button-renderer';
 import { ChildNodesEventPreventSlimmer } from '../../../helpers/event-manager/slimmers/child-nodes-event-prevent-slimmer';
 import { TextColorsTokenType } from '../../../types/design-token.type';
+import { AriaAttributesValueMapper } from '../../../helpers/slimmers/mutation-observer/aria-attributes-value-mapper';
 /**
 + * @vegaVersion 2.34.0
 + */
@@ -14,6 +15,7 @@ export declare class VegaRichTextEditorToolbarButton {
   protected clickEventEmitter: EventEmitSlimmerBase;
   protected eventPrevent: ChildNodesEventPreventSlimmer;
   protected readonly renderer: VegaRichTextEditorToolbarButtonRenderer;
+  protected ariaAttributesValueMapper: AriaAttributesValueMapper;
   host: HTMLVegaRichTextEditorToolbarButtonElement;
   /**
    * Specifies whether the rich text editor toolbar button element is disabled.

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

@@ -45,7 +45,9 @@ import { InternalCodeBlockSelectionController } from './slimmers/controllers/int
 import { SourceEditToolbarButtonSlimmer } from './slimmers/renderers/tools/source-edit-toolbar-button-slimmer';
 import { VegaRTEExtension } from './extensions/extension.abstract';
 import { RTEExtensionController } from './slimmers/controllers/extension-controller';
+import { WordCountController } from './slimmers/controllers/word-count-controller';
 import { VegaRichTextEditorSourceViewRenderer } from './slimmers/renderers/vega-rich-text-editor-source-view-renderer';
+import { AriaAttributesValueMapper } from '../../helpers/slimmers/mutation-observer/aria-attributes-value-mapper';
 /**
  * The rich text editor enables users to format text for a variety of publishers.
  *
@@ -53,6 +55,7 @@ import { VegaRichTextEditorSourceViewRenderer } from './slimmers/renderers/vega-
  */
 export declare class VegaRichTextEditor {
   protected readonly globalSlimmers: GlobalSlimmers;
+  protected ariaAttributesValueMapper: AriaAttributesValueMapper;
   protected translationSlimmer: TranslationSlimmer<HTMLVegaRichTextEditorElement>;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaRichTextEditorElement>;
   protected formFieldController: FormFieldControllerSlimmer<VegaRTEContentBlock[]>;
@@ -93,6 +96,7 @@ export declare class VegaRichTextEditor {
   protected readonly historyController: HistoryController;
   protected readonly internalCodeBlockSelectionController: InternalCodeBlockSelectionController;
   protected readonly rteExtensionController: RTEExtensionController;
+  protected readonly wordCountController: WordCountController;
   protected readonly sourceCodeChangeEventEmitter: EventEmitSlimmerBase;
   protected readonly richTextEditorSourceViewRenderer: VegaRichTextEditorSourceViewRenderer;
   host: HTMLVegaRichTextEditorElement;

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

@@ -16,6 +16,22 @@ export declare class LinkEditorController extends VegaSlimmer {
   protected linkEditorStateManager: VegaRichTextLinkEditor['linkEditorStateManager'];
   private readonly linkUrlNormalizer;
   private readonly linkTypeHandlers;
+  /**
+   * The element the trigger click listener is currently attached to (the link
+   * wrapper acting as the popover target).
+   */
+  private triggerListenerEl;
+  /**
+   * Whether the popover was opened via a keyboard or screen-reader (VoiceOver)
+   * activation. When true, focus is moved into the popover so screen reader
+   * users land on the Edit button.
+   */
+  private isVoiceOverTrigger;
+  /**
+   * The element that had focus when the VoiceOver activation happened, so focus
+   * can be restored to the link once the popover is hidden.
+   */
+  private focusReturnEl;
   /** Initializes the popover target after the component loads. */
   componentDidLoad(): void;
   /** Notifies observers after each render cycle. */
@@ -88,6 +104,58 @@ export declare class LinkEditorController extends VegaSlimmer {
    * @returns {void} No return value.
    */
   private updatePopoverTarget;
+  /**
+   * Attaches a capture-phase click listener to the link wrapper (the popover
+   * target) so a keyboard/VoiceOver activation can be distinguished from a real
+   * pointer click before the popover opens. Re-attaches when the target changes.
+   *
+   * @returns {void} No return value.
+   */
+  private attachTriggerListener;
+  /**
+   * Removes the trigger listener from the previously observed element.
+   *
+   * @returns {void} No return value.
+   */
+  private detachTriggerListener;
+  /**
+   * Records whether the popover was opened via a keyboard/VoiceOver activation
+   * and, if so, the element to restore focus to when the popover closes.
+   *
+   * @param {MouseEvent} e - The click event on the link wrapper.
+   * @returns {void} No return value.
+   */
+  private readonly handleTriggerClick;
+  /**
+   * Determines whether a click on the link wrapper came from a keyboard or
+   * screen reader (VoiceOver) rather than a real pointer.
+   *
+   * A genuine pointer click lands inside the activated element. Keyboard (Enter,
+   * `detail === 0`) and VoiceOver activations dispatch a click with coordinates
+   * that are not on the element, so we treat any click whose point falls outside
+   * the wrapper as an assistive-technology activation.
+   *
+   * @param {MouseEvent} e - The click event on the link wrapper.
+   * @returns {boolean} True when the activation is keyboard/screen-reader driven.
+   */
+  private isKeyboardOrScreenReaderActivation;
+  /**
+   * Moves focus to the first focusable element within the popover content (the
+   * Edit button) so VoiceOver users land inside the opened toolbar.
+   *
+   * Deferred to the next macrotask so it runs after the editor has finished
+   * placing the caret/focus into the content area on the activating click.
+   *
+   * @returns {void} No return value.
+   */
+  private focusPopoverContentForVoiceOver;
+  /**
+   * Restores focus to the link wrapper after the popover is hidden following a
+   * VoiceOver activation.
+   *
+   * @returns {void} No return value.
+   */
+  private restoreFocusAfterVoiceOver;
   /**
    * Preserves an unchanged mailto URL when the form edits are equivalent.
    *