@globalpayments/vega 2.99.0 → 2.101.0

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.
    *

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;
+}