@globalpayments/vega 2.98.0 → 2.100.0

package/dist/collection/components/vega-rich-text-editor/constants/constant.js

@@ -32,6 +32,14 @@ export const RTE_TEXT_COLORS = [
   },
 ];
 export const ZERO_WIDTH_SPACE = '\u200b';
+// Identifies the input source that triggered a value flush.
+export var RTEUpdateSource;
+(function (RTEUpdateSource) {
+  RTEUpdateSource["Default"] = "default";
+  RTEUpdateSource["Composition"] = "composition";
+})(RTEUpdateSource || (RTEUpdateSource = {}));
+// Event property key used to carry the update source across the synthetic beforeinput event.
+export const RTE_UPDATE_SOURCE_KEY = '__updateSource';
 export const VegaRTEDefaultTextStyleItems = [
   { key: 'title' },
   { key: 'subtitle' },
@@ -78,3 +86,20 @@ export const VegaRTEOneRowHeightPx = 22;
 export const RTE_DEFAULT_LINK_TYPE_KEY = 'url';
 export const RTE_EMAIL_LINK_TYPE_KEY = 'email';
 export const RTE_SUPPORTED_LINK_TYPE_KEYS = [RTE_DEFAULT_LINK_TYPE_KEY, RTE_EMAIL_LINK_TYPE_KEY];
+/**
+ * Semantic marker used by renderers to identify elements that terminate
+ * continue-inline grouping during HTML -> DTO conversion.
+ */
+export const RTE_BLOCK_BOUNDARY_ATTRIBUTE = 'data-vega-rte-block-boundary';
+/**
+ * Custom DataTransfer MIME type used to tag a synthetic paste with the chosen
+ * paste mode (e.g. 'rich' or 'plain'), so downstream paste handling can decide
+ * whether to preserve the original inline styles.
+ */
+export const RTE_PASTE_MODE_DATA_TYPE = 'application/x-vega-rte-paste-mode';
+/**
+ * Custom DataTransfer MIME type value used to indicate that the paste content
+ * originated from Microsoft Word.
+ */
+export const RTE_PASTE_MODE_WORD = 'word';
+export const RTE_WORD_COUNT_KEY = 'rte-word-count';

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/commit-value-strategy.js

@@ -0,0 +1,13 @@
+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 class CommitValueStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action) {
+    return action.candidate;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/actions/commit-value-action.js

@@ -0,0 +1,20 @@
+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 const COMMIT_VALUE = 'COMMIT_VALUE';
+/**
+ * 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 class CommitValueAction extends ModifyContentAction {
+  constructor(candidate, previous, host) {
+    super();
+    this.candidate = candidate;
+    this.previous = previous;
+    this.host = host;
+    this.isFlushable = false;
+    this.type = COMMIT_VALUE;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/annotations/text-style-default-styles.js

@@ -1,9 +1,10 @@
+export const TEXT_STYLE_DEFAULT_FONT_WEIGHT = '500';
 const TEXT_STYLE_BASE = {
   fontFamily: 'Inter',
   fontSize: '16px',
   lineHeight: '22px',
   minHeight: '22px',
-  fontWeight: '500',
+  fontWeight: TEXT_STYLE_DEFAULT_FONT_WEIGHT,
 };
 const PARAGRAPH_TEXT_STYLE = Object.assign(Object.assign({}, TEXT_STYLE_BASE), { marginTop: '0px', marginBottom: '0px' });
 export const TEXT_STYLE_VALUES = [

package/dist/collection/components/vega-rich-text-editor/dto/blocks/block.abstract.js

@@ -158,6 +158,17 @@ export class RTEBlock {
       }
     }
   }
+  /**
+   * Whether caret nearest-element detection may descend into this block's children.
+   * Transparent wrappers (e.g. html-block) return true so the caret resolves to the
+   * real inner node; atomic widgets like the table block return false so the caret
+   * stays anchored to the block boundary.
+   *
+   * @returns {boolean} True when descending is allowed.
+   */
+  allowsCaretDescend() {
+    return true;
+  }
   /**
    * Get the first node of the block
    *
@@ -172,6 +183,17 @@ export class RTEBlock {
     }
     return firstItem;
   }
+  /**
+   * 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() {
+    var _a;
+    return ((_a = this.children) !== null && _a !== void 0 ? _a : [])
+      .map((child) => child.getPlainText())
+      .join('');
+  }
   /**
    * Check if the block is a list item block
    *

package/dist/collection/components/vega-rich-text-editor/dto/blocks/list-item-block.js

@@ -103,6 +103,16 @@ export class RTEListItemBlock extends RTETextBlock {
     }
     return super.getLastNode();
   }
+  /**
+   * @inheritDoc
+   */
+  getPlainText() {
+    var _a;
+    const nestListText = ((_a = this.nestList) !== null && _a !== void 0 ? _a : [])
+      .map((list) => list.getPlainText())
+      .join('');
+    return super.getPlainText() + nestListText;
+  }
   /**
    * Create a new list item block.
    *

package/dist/collection/components/vega-rich-text-editor/dto/content-state.js

@@ -24,6 +24,8 @@ import { LogUtility } from '../../../utils/log';
 import { HTMLContentCleaner } from '../slimmers/controllers/html-cleaner';
 import { RTEFilterStylesStrategyRegistry } from './filter-styles-strategies/filter-styles-strategy-registry';
 import { DeleteSelectedContentStrategy } from './action-handle-strategies/modify-content-strategies/delete-selected-content-strategy';
+import { CommitValueStrategy } from './action-handle-strategies/modify-content-strategies/commit-value-strategy';
+import { COMMIT_VALUE } from './actions/commit-value-action';
 import { ReplaceNestListAction } from './actions/replace-nest-list-action';
 /**
  * Class representing the content state of the rich text editor.
@@ -189,6 +191,14 @@ export class VegaRTEContent {
     const lastBlock = this.children[this.children.length - 1];
     return lastBlock.getLastNode();
   }
+  /**
+   * 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() {
+    return this.children.map((block) => block.getPlainText()).join('');
+  }
   /**
    * Convert text to list.
    *
@@ -267,6 +277,7 @@ export class VegaRTEContent {
   ActionHandleStrategyRegistry.register(ModifyContentActionType.TRANSFORM_TO_CODE_BLOCK, VegaRTEContent.name, new BlockTransformToCodeBlockStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.UPDATE_CURSOR_POSITION, VegaRTEContent.name, new UpdateCursorPositionStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_SELECTED_CONTENT, VegaRTEContent.name, new DeleteSelectedContentStrategy());
+  ActionHandleStrategyRegistry.register(COMMIT_VALUE, VegaRTEContent.name, new CommitValueStrategy());
 })();
 /** Minimize-safe type discriminator for VegaRTEContent. */
 VegaRTEContent.dtoName = 'VegaRTEContent';

package/dist/collection/components/vega-rich-text-editor/dto/filter-styles-strategies/filter-styles-strategy-registry.js

@@ -39,6 +39,7 @@ export class RTEFilterStylesStrategyRegistry {
    * @param {RTEFilterStyles} styles - The full set of styles to filter.
    * @param {string[]} classNames - The class names to consider.
    * @returns {RTEFilterInlineStylesResult} The result of filtering, including the remaining styles and class names.
+   * The instance is also passed to matched strategies so they can make decisions from DTO annotations.
    */
   static executeTheStrategyFilterAction(blockOrNodeInstance, styles, classNames) {
     const dtoClassName = blockOrNodeInstance.dtoName;
@@ -47,7 +48,7 @@ export class RTEFilterStylesStrategyRegistry {
       return strategy.canFilter(blockOrNodeInstance);
     });
     return matchedStrategies.reduce((result, strategy) => {
-      return strategy.filterAndDeleteStyles(result.styles, result.classNames);
+      return strategy.filterAndDeleteStyles(result.styles, result.classNames, blockOrNodeInstance);
     }, {
       styles,
       classNames,

package/dist/collection/components/vega-rich-text-editor/dto/filter-styles-strategies/filter-styles-strategy.abstract.js

@@ -36,13 +36,16 @@ export class RTEFilterStylesStrategy {
     return annotations;
   }
   /**
-   * Filters and deletes the matched styles from the full styles object, add the corresponding class name if necessary, and returns the result.
+   * Filters and deletes matched styles from the full styles object, adds the corresponding class name if necessary, and returns the result.
    *
    * @param {RTEFilterStyles} fullStyles - The full set of styles to filter.
    * @param {string[]} classNames - The class names to consider.
+   * @param {RTEBlock | RTENode} [_blockOrNodeInstance] - The block or node the styles belong to. It is optional for strategies that only need styles and class names.
    * @returns {RTEFilterInlineStylesResult} The filtered styles and class names.
    */
-  filterAndDeleteStyles(fullStyles, classNames) {
+  filterAndDeleteStyles(fullStyles, classNames, 
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _blockOrNodeInstance) {
     const classSet = new Set(classNames);
     const shouldAddClass = this.extractAndDeleteMatchedStyles(fullStyles);
     if (shouldAddClass && this.classNameToBeAdded) {

package/dist/collection/components/vega-rich-text-editor/dto/filter-styles-strategies/text-node/title-heading-node-filter-styles-strategy.js

@@ -1,8 +1,15 @@
+import { NodeAnnotationTypeEnum } from '../../annotations/node-annotation.abstract';
+import { TEXT_STYLE_DEFAULT_FONT_WEIGHT } from '../../annotations/text-style-default-styles';
 import { RTEFilterStylesStrategy } from '../filter-styles-strategy.abstract';
 import { Predicate } from '../predicate';
 /**
- * The TitleHeadingNodeFilterStylesStrategy is responsible for filtering styles from text nodes that are children of title and heading blocks.
- * In title and heading blocks, the text nodes will have a default bold style.
+ * Filters the default bold style from text nodes inside title and heading blocks.
+ * The source DTO distinguishes an explicitly non-bold node (`bold: false`) from
+ * a node with no bold annotation, even though both initially produce no weight in `fullStyles`.
+ *
+ * Bold nodes keep the existing strip/refill behaviour. Default nodes without a bold annotation
+ * remain bare for compatibility, while explicitly non-bold nodes receive the base weight so
+ * source-mode refill does not restore bold (VD-9375).
  */
 export class TitleHeadingNodeFilterStylesStrategy extends RTEFilterStylesStrategy {
   constructor() {
@@ -29,6 +36,19 @@ export class TitleHeadingNodeFilterStylesStrategy extends RTEFilterStylesStrateg
   filterAnnotations(annotations) {
     return annotations;
   }
+  /**
+   * Removes the default bold weight and preserves an explicit non-bold marker when needed.
+   *
+   * @inheritDoc
+   */
+  filterAndDeleteStyles(fullStyles, classNames, blockOrNodeInstance) {
+    var _a;
+    const result = super.filterAndDeleteStyles(fullStyles, classNames);
+    if (this.isExplicitlyNonBold(blockOrNodeInstance) && ((_a = result.styles) === null || _a === void 0 ? void 0 : _a.fontWeight) === undefined) {
+      result.styles = Object.assign(Object.assign({}, result.styles), { fontWeight: TitleHeadingNodeFilterStylesStrategy.NON_BOLD_FONT_WEIGHT });
+    }
+    return result;
+  }
   /**
    * Determines whether the dto instance is text node and its parent block is a heading or title.
    *
@@ -58,6 +78,18 @@ export class TitleHeadingNodeFilterStylesStrategy extends RTEFilterStylesStrateg
     const selectors = this.parentElementSelectors.map((key) => `.${TitleHeadingNodeFilterStylesStrategy.RTE_CONTENT_CONTAINER_CLASS_NAME} ${key}`);
     return `${selectors.join(',')} { ${this.convertStylesMapToCssText()} }`;
   }
+  /**
+   * Checks the annotation rather than `fullStyles`, because both an explicit `bold: false` node and
+   * a node without a bold annotation produce no font weight before this strategy runs.
+   *
+   * @param {RTEBlock | RTENode} [blockOrNodeInstance] - The block or node the styles belong to.
+   * @returns {boolean} True when the node has a `bold: false` annotation.
+   */
+  isExplicitlyNonBold(blockOrNodeInstance) {
+    var _a;
+    const boldAnnotation = (_a = blockOrNodeInstance) === null || _a === void 0 ? void 0 : _a.getAnnotationByType(NodeAnnotationTypeEnum.BOLD);
+    return (boldAnnotation === null || boldAnnotation === void 0 ? void 0 : boldAnnotation.bold) === false;
+  }
   /**
    * Checks if the parent block of the given node instance is a heading or title.
    *
@@ -96,6 +128,8 @@ export class TitleHeadingNodeFilterStylesStrategy extends RTEFilterStylesStrateg
 TitleHeadingNodeFilterStylesStrategy.BOLD_STYLES = {
   fontWeight: '700',
 };
+/** Base weight used to preserve an explicitly non-bold title or heading node. */
+TitleHeadingNodeFilterStylesStrategy.NON_BOLD_FONT_WEIGHT = TEXT_STYLE_DEFAULT_FONT_WEIGHT;
 TitleHeadingNodeFilterStylesStrategy.NON_HEADING_TITLE_ELEMENT_TAGS = [
   'TD',
   'TH',

package/dist/collection/components/vega-rich-text-editor/dto/nodes/code-block-node.js

@@ -32,6 +32,12 @@ export class RTECodeBlockNode extends RTEDecoratorNode {
   toJSON() {
     return { id: this.id, type: 'text', text: this.text, language: this.language };
   }
+  /**
+   * @inheritDoc
+   */
+  getPlainText() {
+    return this.text;
+  }
   /**
    * @inheritDoc
    */

package/dist/collection/components/vega-rich-text-editor/dto/nodes/node.abstract.js

@@ -134,6 +134,14 @@ export class RTENode {
   isTextNode() {
     return false;
   }
+  /**
+   * 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() {
+    return '';
+  }
   /**
    * Get the HTMLElement reference associated with this node.
    *

package/dist/collection/components/vega-rich-text-editor/dto/nodes/text-node.js

@@ -218,6 +218,12 @@ export class RTETextNode extends RTENode {
   isContentEditable() {
     return true;
   }
+  /**
+   * @inheritDoc
+   */
+  getPlainText() {
+    return this.text;
+  }
   /**
    * 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/collection/components/vega-rich-text-editor/dto/renderers/blocks/block-text-nodes-renderer.abstract.js

@@ -3,6 +3,7 @@ import { InternalAnnotationTypeEnum } from '../../annotations/annotation.abstrac
 import { RTEBlockRenderer } from './block-renderer.abstract';
 import RTELinkWrapperRenderer from './link-wrapper-renderer';
 import RTEDTORendererManager from '../../../../../helpers/rte-manager/dto-renderer-manager';
+import { NodeTypeEnum } from '../../nodes/node.abstract';
 import RTETextNodeRenderer from '../nodes/text-node-renderer';
 /**
  * Abstract class for rendering blocks that contain text nodes with support for rendering text with link styles.
@@ -75,9 +76,25 @@ export class RTEBlockTextNodesRenderer extends RTEBlockRenderer {
    */
   renderNodeFromDepth(node, depth, renderContext) {
     if (depth === 0) {
-      const nodeRenderer = RTEDTORendererManager.getRTERenderer(node.type);
-      return nodeRenderer.render(node, renderContext, h);
+      return this.getNodeRenderer(node).render(node, renderContext, h);
     }
-    return RTETextNodeRenderer.renderFromAnnotation(node, node.getInlineHtmlAnnotationAtDepth(depth));
+    const annotation = node.getInlineHtmlAnnotationAtDepth(depth);
+    if (node.type !== NodeTypeEnum.TEXT) {
+      // Non-text nodes (e.g. tokens) must keep their own markup even when nested inside a
+      // shared inline HTML wrapper; the plain text renderer would drop attributes such as
+      // token-key. Render via the node's own renderer, then re-apply the remaining chain.
+      const inner = this.getNodeRenderer(node).render(node, renderContext, h);
+      return annotation ? RTETextNodeRenderer.wrapWithInlineHtml(inner, annotation) : inner;
+    }
+    return RTETextNodeRenderer.renderFromAnnotation(node, annotation);
+  }
+  /**
+   * Resolves the registered renderer for the given node's type.
+   *
+   * @param {RTETextNode} node - The node whose renderer is needed.
+   * @returns {VegaRTEBaseRenderer<RTENode, VNode>} The node renderer.
+   */
+  getNodeRenderer(node) {
+    return RTEDTORendererManager.getRTERenderer(node.type);
   }
 }

package/dist/collection/components/vega-rich-text-editor/dto/renderers/nodes/text-node-renderer.js

@@ -16,6 +16,18 @@ class RTETextNodeRenderer extends RTENodeRenderer {
     const textNodeDom = this.renderText(node);
     return annotation ? this.renderWithWrapper(textNodeDom, annotation) : textNodeDom;
   }
+  /**
+   * Wrap an already-rendered inner element with the given inline HTML annotation chain.
+   * Lets non-text nodes (e.g. tokens) keep their own markup while still being nested
+   * inside a shared inline HTML wrapper emitted by the grouped node renderer.
+   *
+   * @param {HTMLElement} inner - The already-rendered inner element to wrap.
+   * @param {InlineHtmlAnnotation} annotation - The inline HTML annotation chain to apply.
+   * @returns {HTMLElement} The wrapped element.
+   */
+  wrapWithInlineHtml(inner, annotation) {
+    return this.renderWithWrapper(inner, annotation);
+  }
   render(node) {
     return this.renderFromAnnotation(node, node.getAnnotationByType(NodeAnnotationTypeEnum.INLINE_HTML));
   }

package/dist/collection/components/vega-rich-text-editor/extensions/base-toolbar-button-renderer.js

@@ -50,7 +50,7 @@ export class VegaRTEToolbarButtonRenderer {
    * @returns {VegaRTERenderResult} - The render result for the dropdown.
    */
   renderDropdown(h, editorContext, dropdownProps, children) {
-    return h('vega-dropdown', Object.assign({ trigger: 'click', searchable: false, maxWidth: '200', itemDisplayRule: 'ellipsis', isScreenPosition: true, 
+    return h('vega-dropdown', Object.assign({ trigger: 'click', searchable: false, maxWidth: '200', itemDisplayRule: 'ellipsis', isScreenPosition: true, role: 'presentation', 
       // eslint-disable-next-line jsdoc/require-jsdoc
       ref: (el) => {
         this.dropdownEl = el;
@@ -134,29 +134,31 @@ export class VegaRTEToolbarButtonRenderer {
    * @returns {VegaRTERenderResult} - The render result for the button.
    */
   renderButton(h, editorContext, buttonProps) {
-    const { icon, label, showArrowIcon, tooltip } = buttonProps;
+    const { icon, label, showArrowIcon, tooltip, ariaLabel } = buttonProps;
     const isDisabled = this.isDisabled(editorContext);
     const button = h('vega-rich-text-editor-toolbar-button', {
-      disabled: isDisabled,
-      icon: icon,
-      hidden: this.isHidden(editorContext),
-      selected: this.isSelected(editorContext),
+      'disabled': isDisabled,
+      'icon': icon,
+      'data-aria-label': ariaLabel !== null && ariaLabel !== void 0 ? ariaLabel : label,
+      'hidden': this.isHidden(editorContext),
+      'selected': this.isSelected(editorContext),
       // eslint-disable-next-line jsdoc/require-jsdoc
-      ref: (el) => {
+      'ref': (el) => {
         this.buttonEl = el;
         DomNodeSubjectObserverFactory.addUniqueObserverToNode(el, VegaClick, () => this.handleButtonClick(editorContext));
       },
-      onMouseDown: this.preventDefault,
+      'onMouseDown': this.preventDefault,
       // eslint-disable-next-line jsdoc/require-jsdoc
-      onKeyDown: (e) => this.handleButtonKeyDown(e),
+      'onKeyDown': (e) => this.handleButtonKeyDown(e),
     }, [
       this.renderButtonLabel(h, editorContext, label),
       showArrowIcon
         ? h('vega-icon', {
-          size: 'size-8',
-          color: isDisabled ? 'text-disabled' : 'text-secondary',
-          style: { marginLeft: '8px' },
-          icon: VegaInternalIconManager.getIconKey('chevron-down'),
+          'size': 'size-8',
+          'color': isDisabled ? 'text-disabled' : 'text-secondary',
+          'style': { marginLeft: '8px' },
+          'aria-hidden': 'true',
+          'icon': VegaInternalIconManager.getIconKey('chevron-down'),
         })
         : null,
     ].filter(isNonNullable));
@@ -177,8 +179,9 @@ export class VegaRTEToolbarButtonRenderer {
     if (label) {
       const isDisabled = this.isDisabled(editorContext);
       return h('vega-font', {
-        variant: 'font-field-label-sm',
-        color: isDisabled ? 'text-disabled' : 'text-primary',
+        'variant': 'font-field-label-sm',
+        'color': isDisabled ? 'text-disabled' : 'text-primary',
+        'aria-hidden': 'true',
       }, editorContext.translation.t(label));
     }
     return null;
@@ -210,6 +213,15 @@ export class VegaRTEToolbarButtonRenderer {
   preventDefault(e) {
     e.preventDefault();
   }
+  /**
+   * Moves focus to the toolbar button. Targets the inner focusable `<button>`
+   * inside the button's shadow root, falling back to the host element.
+   */
+  focusToolbarButton() {
+    var _a, _b, _c, _d;
+    const innerButton = (_c = (_b = (_a = this.buttonEl) === null || _a === void 0 ? void 0 : _a.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('button')) !== null && _c !== void 0 ? _c : null;
+    (_d = (innerButton !== null && innerButton !== void 0 ? innerButton : this.buttonEl)) === null || _d === void 0 ? void 0 : _d.focus();
+  }
   /**
    * Recursively searches for a dropdown list item by its key.
    *
@@ -263,14 +275,14 @@ export class VegaRTEToolbarButtonRenderer {
    * @param {KeyboardEvent} e The keyboard event.
    */
   handleItemsKeyDown(e) {
-    var _a, _b, _c;
+    var _a, _b;
     if (e.code === 'Escape') {
       e.preventDefault();
       e.stopPropagation();
       if (this.dropdownEl) {
         void this.dropdownEl.hide();
       }
-      (_a = this.buttonEl) === null || _a === void 0 ? void 0 : _a.focus();
+      this.focusToolbarButton();
       return;
     }
     if (e.code !== 'ArrowDown' && e.code !== 'ArrowUp') {
@@ -288,7 +300,7 @@ export class VegaRTEToolbarButtonRenderer {
     for (let offset = 0; offset < items.length; offset++) {
       const index = (startIndex + offset * direction + items.length) % items.length;
       if (!items[index].disabled) {
-        (_c = (_b = items[index].shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('li')) === null || _c === void 0 ? void 0 : _c.focus();
+        (_b = (_a = items[index].shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('li')) === null || _b === void 0 ? void 0 : _b.focus();
         return;
       }
     }

package/dist/collection/components/vega-rich-text-editor/extensions/block-boundary-registry.js

@@ -0,0 +1,34 @@
+/**
+ * Per-editor registry for block-boundary predicates contributed by extensions.
+ */
+export class BlockBoundaryRegistry {
+  constructor() {
+    this.predicates = new Set();
+  }
+  /**
+   * Register a block-boundary predicate.
+   *
+   * @param {BlockBoundaryPredicate} predicate - Predicate to register.
+   * @returns {() => void} Unregister callback.
+   */
+  register(predicate) {
+    this.predicates.add(predicate);
+    return () => {
+      this.predicates.delete(predicate);
+    };
+  }
+  /**
+   * Returns true when any registered predicate marks the element as a boundary.
+   *
+   * @param {HTMLElement} element - Element to inspect.
+   * @returns {boolean} Whether the element is a boundary.
+   */
+  isBoundary(element) {
+    for (const predicate of this.predicates) {
+      if (predicate(element)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/renderers/blockquote-toolbar-button-renderer.js

@@ -33,6 +33,7 @@ export class RTEBlockquoteToolbarButtonRenderer extends VegaRTEToolbarButtonRend
   render(createElement, editorContext) {
     return this.renderButton(createElement, editorContext, {
       icon: 'quote-left',
+      ariaLabel: editorContext.translation.t('Block quote'),
       tooltip: { text: 'Block quote' },
     });
   }

package/dist/collection/components/vega-rich-text-editor/extensions/copy/copy-toolbar-button-renderer.js

@@ -18,6 +18,7 @@ export class RTECopyToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
   render(h, editorContext) {
     return this.renderButton(h, editorContext, {
       icon: 'rte-copy',
+      ariaLabel: editorContext.translation.t('Copy'),
       tooltip: { text: 'Copy' },
     });
   }

package/dist/collection/components/vega-rich-text-editor/extensions/cut/cut-toolbar-button-renderer.js

@@ -19,6 +19,7 @@ export class RTECutToolbarButtonRenderer extends RTECopyToolbarButtonRenderer {
   render(h, editorContext) {
     return this.renderButton(h, editorContext, {
       icon: 'rte-cut',
+      ariaLabel: editorContext.translation.t('Cut'),
       tooltip: { text: 'Cut' },
     });
   }

package/dist/collection/components/vega-rich-text-editor/extensions/extension.abstract.js

@@ -10,6 +10,7 @@ import { methodPlaceholder } from 'vega-slimmer/core';
 import htmlElementToAnnotationGenerator from '../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator';
 import { RTEFilterStylesStrategyRegistry } from '../dto/filter-styles-strategies/filter-styles-strategy-registry';
 import { RTEExtensionStateStore } from './rte-extension-state-store';
+import stateEntityRenderingRegistry from '../slimmers/controllers/state-entity-rendering-registry';
 const patchedBlockClasses = new WeakSet();
 const annotationHandlersByClass = new WeakMap();
 /**
@@ -258,4 +259,23 @@ export class VegaRTEExtension {
   registerAnnotationHandler(handler) {
     htmlElementToAnnotationGenerator.registerHandler(handler);
   }
+  /**
+   * Register an extension-defined block-boundary predicate for the current editor instance.
+   *
+   * @param {BlockBoundaryPredicate} predicate - Predicate to register.
+   * @returns {Nullable<() => void>} Unregister callback when context is available.
+   */
+  registerBlockBoundaryPredicate(predicate) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.blockBoundaryRegistry) === null || _b === void 0 ? void 0 : _b.register(predicate)) !== null && _c !== void 0 ? _c : null;
+  }
+  /**
+   * Get the registered dto by dom element.
+   *
+   * @param {HTMLElement} el - The DOM element to get the registered DTO for.
+   * @returns {Nullable<RTENode | RTEBlock>} - The registered DTO associated with the DOM element.
+   */
+  getDTOEntityByDom(el) {
+    return stateEntityRenderingRegistry.getEntityByDOM(el);
+  }
 }