@heartlandone/vega 2.100.0 → 2.102.0

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

@@ -26,7 +26,6 @@ import { RTEDecoratorNode } from './decorator-node';
 export class RTEImageNode extends RTEDecoratorNode {
   constructor(id, url, parentBlock, annotationMap) {
     super(id, annotationMap);
-    this.dtoName = RTEImageNode.dtoName;
     this.type = NodeTypeEnum.IMAGE;
     this.url = url;
     this.parent = parentBlock;
@@ -89,7 +88,7 @@ export class RTEImageNode extends RTEDecoratorNode {
    * @inheritDoc
    */
   doAnnotationActionApply(action) {
-    const strategy = ActionHandleStrategyRegistry.get(AnnotationAction.name, RTEImageNode.name);
+    const strategy = ActionHandleStrategyRegistry.get(AnnotationAction.typeName, RTEImageNode.typeName);
     if (strategy) {
       strategy.execute(action, this);
     }
@@ -101,8 +100,9 @@ export class RTEImageNode extends RTEDecoratorNode {
     ActionHandleStrategyRegistry.executeTheStrategy(action, this);
   }
 }
+RTEImageNode.typeName = 'RTEImageNode';
+// eslint-disable-next-line @globalpayments/vega-eslint/vega-class-member-order-rule
 (() => {
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.UPDATE_IMAGE_NODE_URL, RTEImageNode.name, new ImageUpdateUrlStrategy());
-  ActionHandleStrategyRegistry.register(AnnotationAction.name, RTEImageNode.name, new ImageSetAnnotationMapStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.UPDATE_IMAGE_NODE_URL, RTEImageNode.typeName, new ImageUpdateUrlStrategy());
+  ActionHandleStrategyRegistry.register(AnnotationAction.typeName, RTEImageNode.typeName, new ImageSetAnnotationMapStrategy());
 })();
-RTEImageNode.dtoName = 'RTEImageNode';

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

@@ -13,6 +13,7 @@ import { methodPlaceholder } from 'vega-slimmer/core';
 import { RTEAnnotationStyle } from '../annotations/annotation-style';
 import { RTEFilterStylesStrategyRegistry } from '../filter-styles-strategies/filter-styles-strategy-registry';
 import { escapeHtmlAttribute } from '../../helpers/utils';
+import { Discriminated } from '../../../../helpers/discriminator/discriminated';
 export var NodeTypeEnum;
 (function (NodeTypeEnum) {
   NodeTypeEnum["TEXT"] = "TEXT";
@@ -22,14 +23,10 @@ export var NodeTypeEnum;
 /**
  * Abstract class for all nodes
  */
-export class RTENode {
+export class RTENode extends Discriminated {
   constructor(id, annotationMap) {
+    super();
     this.annotationMap = new Map();
-    /**
-     * Minimize-safe type discriminator. Each concrete sub-class declares its own
-     * `static readonly dtoName = 'ClassName'`.
-     */
-    this.dtoName = this.constructor.name;
     this.id = id;
     if (annotationMap) {
       this.annotationMap = annotationMap;
@@ -43,7 +40,7 @@ export class RTENode {
    * @param {VegaRTETransformOptions} options - Options for transforming the node.
    */
   static from(json, parentBlock, options) {
-    throw new Error(`[Vega] ${this.constructor.name}.from(${JSON.stringify(json)}, ${parentBlock}, ${options}) is not implemented. Please implement this method in the subclass.`);
+    throw new Error(`[Vega] ${this.typeName}.from(${JSON.stringify(json)}, ${parentBlock}, ${options}) is not implemented. Please implement this method in the subclass.`);
   }
   /**
    * Creates different types of text annotations based on the provided type and value.
@@ -234,3 +231,4 @@ export class RTENode {
     methodPlaceholder(action);
   }
 }
+RTENode.typeName = 'RTENode';

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

@@ -46,7 +46,6 @@ import { escapeHtml } from '../../helpers/utils';
 export class RTETextNode extends RTENode {
   constructor(id, text, parentBlock, annotationMap) {
     super(id, annotationMap);
-    this.dtoName = RTETextNode.dtoName;
     this.type = NodeTypeEnum.TEXT;
     this.parent = parentBlock;
     this.text = text;
@@ -282,24 +281,24 @@ export class RTETextNode extends RTENode {
    * Registers the action strategies for the RTETextNode.
    */
   registerModifyStrategy() {
-    const dtoClassName = this.constructor.name;
+    const dtoClassName = this.typeName;
     if (!RTETextNode.registerActionStrategyStatus[dtoClassName]) {
       if (this.isContentEditable()) {
         ActionHandleStrategyRegistry.register(ModifyContentActionType.UPDATE_TEXT, dtoClassName, new NodeUpdateTextStrategy());
         ActionHandleStrategyRegistry.register(ModifyContentActionType.REPLACE_SELECTED_TEXT, dtoClassName, new NodeReplaceSelectedTextStrategy());
         ActionHandleStrategyRegistry.register(ModifyContentActionType.LINK_GROUP_NODE_SPLIT, dtoClassName, new LinkGroupNodeSplitStrategy());
-        ActionHandleStrategyRegistry.register(LinkAnnotationAction.name, dtoClassName, new NodeUpdateAnnotationMapStrategy());
+        ActionHandleStrategyRegistry.register(LinkAnnotationAction.typeName, dtoClassName, new NodeUpdateAnnotationMapStrategy());
       }
-      ActionHandleStrategyRegistry.register(TextSplittableAction.name, dtoClassName, new NodeSplitTextStrategy());
+      ActionHandleStrategyRegistry.register(TextSplittableAction.typeName, dtoClassName, new NodeSplitTextStrategy());
       ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_LINK_GROUP, dtoClassName, new DeleteLinkGroupStrategy());
-      ActionHandleStrategyRegistry.register(BoldAnnotationAction.name, dtoClassName, new NodeUpdateAnnotationMapStrategy());
-      ActionHandleStrategyRegistry.register(ClearFormattingAnnotationAction.name, dtoClassName, new NodeUpdateAnnotationMapStrategy());
-      ActionHandleStrategyRegistry.register(ItalicAnnotationAction.name, dtoClassName, new NodeUpdateAnnotationMapStrategy());
-      ActionHandleStrategyRegistry.register(UnderlineAnnotationAction.name, dtoClassName, new NodeUpdateAnnotationMapStrategy());
-      ActionHandleStrategyRegistry.register(TextColorAnnotationAction.name, dtoClassName, new NodeUpdateAnnotationMapStrategy());
-      ActionHandleStrategyRegistry.register(StrikethroughAnnotationAction.name, dtoClassName, new NodeUpdateAnnotationMapStrategy());
-      ActionHandleStrategyRegistry.register(CodeAnnotationAction.name, dtoClassName, new NodeUpdateAnnotationMapStrategy());
-      ActionHandleStrategyRegistry.register(AnnotationAction.name, dtoClassName, new NodeUpdateAnnotationMapStrategy());
+      ActionHandleStrategyRegistry.register(BoldAnnotationAction.typeName, dtoClassName, new NodeUpdateAnnotationMapStrategy());
+      ActionHandleStrategyRegistry.register(ClearFormattingAnnotationAction.typeName, dtoClassName, new NodeUpdateAnnotationMapStrategy());
+      ActionHandleStrategyRegistry.register(ItalicAnnotationAction.typeName, dtoClassName, new NodeUpdateAnnotationMapStrategy());
+      ActionHandleStrategyRegistry.register(UnderlineAnnotationAction.typeName, dtoClassName, new NodeUpdateAnnotationMapStrategy());
+      ActionHandleStrategyRegistry.register(TextColorAnnotationAction.typeName, dtoClassName, new NodeUpdateAnnotationMapStrategy());
+      ActionHandleStrategyRegistry.register(StrikethroughAnnotationAction.typeName, dtoClassName, new NodeUpdateAnnotationMapStrategy());
+      ActionHandleStrategyRegistry.register(CodeAnnotationAction.typeName, dtoClassName, new NodeUpdateAnnotationMapStrategy());
+      ActionHandleStrategyRegistry.register(AnnotationAction.typeName, dtoClassName, new NodeUpdateAnnotationMapStrategy());
       RTETextNode.registerActionStrategyStatus[dtoClassName] = true;
     }
   }
@@ -309,7 +308,7 @@ export class RTETextNode extends RTENode {
   doAnnotationActionApply(action) {
     const selectionRangeAnnotation = this.getAnnotationByType(InternalAnnotationTypeEnum.SELECTION_RANGE);
     if (action instanceof TextSplittableAction && action.doSplit && selectionRangeAnnotation) {
-      const splitStrategy = ActionHandleStrategyRegistry.get(TextSplittableAction.name, this.constructor.name);
+      const splitStrategy = ActionHandleStrategyRegistry.get(TextSplittableAction.typeName, this.typeName);
       if (splitStrategy) {
         const newNode = splitStrategy.execute(action, this);
         if (newNode) {
@@ -350,12 +349,12 @@ export class RTETextNode extends RTENode {
      * 1. Try to get the specific strategy for the action and node type first (e.g., LinkAnnotationAction on RTETextNode).
      * 2. If no specific strategy found, try to get the generic NodeUpdateAnnotationMapStrategy for AnnotationAction on RTETextNode.
      */
-    const strategy = ActionHandleStrategyRegistry.get(action.constructor.name, node.constructor.name);
+    const strategy = ActionHandleStrategyRegistry.get(action.typeName, node.typeName);
     if (strategy) {
       strategy.execute(action, node);
       return;
     }
-    const updateAnnotationMapStrategy = ActionHandleStrategyRegistry.get(AnnotationAction.name, RTETextNode.name);
+    const updateAnnotationMapStrategy = ActionHandleStrategyRegistry.get(AnnotationAction.typeName, RTETextNode.typeName);
     if (updateAnnotationMapStrategy) {
       updateAnnotationMapStrategy.execute(action, node);
       return;
@@ -425,12 +424,27 @@ export class RTETextNode extends RTENode {
     if (this.text === '\n') {
       return `<br>`;
     }
+    if (this.shouldSkipEmptyFormattingMarker()) {
+      return '';
+    }
     if (this.shouldRenderAsPlainText()) {
       return this.text;
     }
     const content = NodeTag === 'code' ? escapeHtml(this.text) : this.text;
     return `<${NodeTag}${attrStr}>${content}</${NodeTag}>`;
   }
+  /**
+   * Formatting toggles at a collapsed caret intentionally keep empty marker
+   * nodes in the live model so future typing inherits the pending style. Those
+   * nodes are not semantic content and should not appear in serialized HTML.
+   *
+   * @returns {boolean} True when the node is an empty formatting-only marker that should be omitted from serialized HTML.
+   */
+  shouldSkipEmptyFormattingMarker() {
+    return (this.text === '' &&
+      this.annotationMap.size > 0 &&
+      Array.from(this.annotationMap.values()).every((annotation) => annotation.isFormattingOnly));
+  }
   /**
    * Determines if the text node should be rendered as plain text.
    *
@@ -452,4 +466,4 @@ export class RTETextNode extends RTENode {
 }
 RTETextNode.registerActionStrategyStatus = {};
 RTETextNode.htmlTag = 'span';
-RTETextNode.dtoName = 'RTETextNode';
+RTETextNode.typeName = 'RTETextNode';

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

@@ -1,5 +1,7 @@
+import { Discriminated } from '../../../../helpers/discriminator/discriminated';
 /**
  * Base renderer class for the rich text editor.
  */
-export class VegaRTEBaseRenderer {
+export class VegaRTEBaseRenderer extends Discriminated {
 }
+VegaRTEBaseRenderer.typeName = 'VegaRTEBaseRenderer';

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

@@ -17,3 +17,4 @@ export class RTEBlockRenderer extends VegaRTEBaseRenderer {
     return ((_a = block.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.render()) || {};
   }
 }
+RTEBlockRenderer.typeName = 'RTEBlockRenderer';

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

@@ -98,3 +98,4 @@ export class RTEBlockTextNodesRenderer extends RTEBlockRenderer {
     return RTEDTORendererManager.getRTERenderer(node.type);
   }
 }
+RTEBlockTextNodesRenderer.typeName = 'RTEBlockTextNodesRenderer';

package/dist/collection/components/vega-rich-text-editor/dto/renderers/blocks/code-block-renderer.js

@@ -74,4 +74,5 @@ class RTECodeBlockRenderer extends RTEBlockRenderer {
     }
   }
 }
+RTECodeBlockRenderer.typeName = 'RTECodeBlockRenderer';
 export default new RTECodeBlockRenderer();

package/dist/collection/components/vega-rich-text-editor/dto/renderers/blocks/html-block-renderer.js

@@ -9,4 +9,5 @@ class RTEHTMLBlockRenderer extends RTEBlockRenderer {
     })));
   }
 }
+RTEHTMLBlockRenderer.typeName = 'RTEHTMLBlockRenderer';
 export default new RTEHTMLBlockRenderer();

package/dist/collection/components/vega-rich-text-editor/dto/renderers/blocks/image-block-renderer.js

@@ -8,4 +8,5 @@ class RTEImageBlockRenderer extends RTEBlockRenderer {
     })));
   }
 }
+RTEImageBlockRenderer.typeName = 'RTEImageBlockRenderer';
 export default new RTEImageBlockRenderer();

package/dist/collection/components/vega-rich-text-editor/dto/renderers/blocks/link-wrapper-renderer.js

@@ -73,7 +73,8 @@ class RTELinkWrapperRenderer {
    * @param {RTERenderContext} context - Context containing render options.
    * @returns {VegaRTERenderResult[]} - Array of rendered HTML elements.
    */
-  render(nodes, linkGroupAnnotation, { editable, host }) {
+  render(nodes, linkGroupAnnotation, renderContext) {
+    const { editable, host } = renderContext;
     const blockNodes = this.groupNodesByLink(nodes);
     return blockNodes
       .flatMap((item) => {
@@ -94,11 +95,11 @@ class RTELinkWrapperRenderer {
         linkAnnotation = item[0].getAnnotationByType(NodeAnnotationTypeEnum.LINK);
         return editable
           ? this.renderLinkEditorWrapper(item, linkAnnotation, linkGroupAnnotation)
-          : this.renderLink(item, linkAnnotation, linkGroupAnnotation);
+          : this.renderLink(item, linkAnnotation, linkGroupAnnotation, true);
       }
       const nodeRenderer = RTEDTORendererManager.getRTERenderer(item.type);
       if (nodeRenderer) {
-        return nodeRenderer.render(item, { editable }, h);
+        return nodeRenderer.render(item, renderContext, h);
       }
     })
       .filter(isNonNullable);
@@ -151,8 +152,27 @@ class RTELinkWrapperRenderer {
           }
         } })));
   }
-  renderLink(linkNodes, linkAnnotation, linkGroupAnnotation) {
-    return (h("a", Object.assign({}, linkGroupAnnotation.toJsx(linkAnnotation)), linkNodes.map((node) => RTETextNodeRenderer.render(node))));
+  renderLink(linkNodes, linkAnnotation, linkGroupAnnotation, handleBookmarkNavigation = false) {
+    const { href } = linkAnnotation.link;
+    const bookmarkClickHandler = handleBookmarkNavigation && (href === null || href === void 0 ? void 0 : href.startsWith('#'))
+      ? (event) => this.handleBookmarkNavigation(event, href)
+      : null;
+    const linkAttributes = Object.assign(Object.assign({}, linkGroupAnnotation.toJsx(linkAnnotation)), (bookmarkClickHandler ? { onClick: bookmarkClickHandler } : {}));
+    return (h("a", Object.assign({}, linkAttributes), linkNodes.map((node) => RTETextNodeRenderer.render(node))));
+  }
+  handleBookmarkNavigation(event, href) {
+    const bookmarkName = href.slice(1);
+    const link = event.currentTarget;
+    const rootNode = link === null || link === void 0 ? void 0 : link.getRootNode();
+    if (!bookmarkName || !rootNode || !('querySelectorAll' in rootNode)) {
+      return;
+    }
+    const bookmarkTarget = Array.from(rootNode.querySelectorAll('a.rte-bookmark[id]')).find((anchor) => anchor.id === bookmarkName);
+    if (!bookmarkTarget) {
+      return;
+    }
+    event.preventDefault();
+    bookmarkTarget.scrollIntoView({ block: 'center', inline: 'nearest' });
   }
   normalizeLinkNodesByDefaultProtocol(linkNodes, host) {
     if (!host || linkNodes.length === 0) {

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

@@ -40,4 +40,5 @@ class RTEListBlockRenderer extends RTEBlockRenderer {
     return depth;
   }
 }
+RTEListBlockRenderer.typeName = 'RTEListBlockRenderer';
 export default new RTEListBlockRenderer();

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

@@ -28,4 +28,5 @@ class RTEListItemBlockRenderer extends RTEBlockTextNodesRenderer {
     return children === null || children === void 0 ? void 0 : children.map((block) => RTEListBlockRenderer.render(block, renderContext));
   }
 }
+RTEListItemBlockRenderer.typeName = 'RTEListItemBlockRenderer';
 export default new RTEListItemBlockRenderer();

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

@@ -22,4 +22,5 @@ class RTETextBlockRenderer extends RTEBlockTextNodesRenderer {
     return children[0].getInlineHtmlTagAtDepth(0);
   }
 }
+RTETextBlockRenderer.typeName = 'RTETextBlockRenderer';
 export default new RTETextBlockRenderer();

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

@@ -75,4 +75,5 @@ class RTECodeBlockNodeRenderer extends RTENodeRenderer {
     }
   }
 }
+RTECodeBlockNodeRenderer.typeName = 'RTECodeBlockNodeRenderer';
 export default new RTECodeBlockNodeRenderer();

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

@@ -115,4 +115,5 @@ class RTEImageNodeRenderer extends RTENodeRenderer {
     return `${RTEDecoratorNode.DECORATOR_CONTAINER_CLASS} ${this.getClasses(node)}`;
   }
 }
+RTEImageNodeRenderer.typeName = 'RTEImageNodeRenderer';
 export default new RTEImageNodeRenderer();

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

@@ -7,3 +7,4 @@ export class RTENodeRenderer extends VegaRTEBaseRenderer {
     }
   }
 }
+RTENodeRenderer.typeName = 'RTENodeRenderer';

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

@@ -48,4 +48,5 @@ class RTETextNodeRenderer extends RTENodeRenderer {
     return h(HtmlTag, Object.assign({}, attrs), node.text || ZERO_WIDTH_SPACE);
   }
 }
+RTETextNodeRenderer.typeName = 'RTETextNodeRenderer';
 export default new RTETextNodeRenderer();

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

@@ -64,11 +64,11 @@ RTEDTOClassManager.registerRTEDTOClass('html-block', RTEHtmlBlock);
 RTEDTOClassManager.registerRTEDTOClass('text', RTETextNode);
 RTEDTOClassManager.registerRTEDTOClass('image', RTEImageNode);
 // Register basic strategies for default block DTOs
-RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTETextBlock.name);
-RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTEListBlock.name);
-RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTEListItemBlock.name);
-RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTEImageBlock.name);
-RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTEHtmlBlock.name);
+RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTETextBlock.typeName);
+RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTEListBlock.typeName);
+RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTEListItemBlock.typeName);
+RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTEImageBlock.typeName);
+RTEDTOActionStrategyManager.registerBlockBasicStrategies(RTEHtmlBlock.typeName);
 // Register element to DTO strategies for default node DTOs, The order of registration matters, the later registered strategy has higher priority.
 ElementToDTOClassStrategyManager.registerElementToBlockStrategy(new ContinueInlineToRTETextBlockStrategy());
 ElementToDTOClassStrategyManager.registerElementToBlockStrategy(new SpanImageToRTEImageBlockStrategy());
@@ -86,32 +86,32 @@ ElementToDTOClassStrategyManager.registerElementToBlockStrategy(new VegaCodeBloc
 ElementToDTOClassStrategyManager.registerElementToNodeStrategy(new InlineElementToTextNodeStrategy());
 ElementToDTOClassStrategyManager.registerElementToNodeStrategy(new PlainTextToTextNodeStrategy());
 // Register filter styles strategies (remove redundant default styles during HTML → DTO conversion)
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new AlignmentFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTEListBlock.dtoName, new AlignmentFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new AlignmentFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTETextNode.dtoName, new TextFormatFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new ParagraphFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new HeadingFilterStylesStrategy(1));
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new HeadingFilterStylesStrategy(2));
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new HeadingFilterStylesStrategy(3));
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new HeadingFilterStylesStrategy(4));
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new HeadingFilterStylesStrategy(5));
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new HeadingFilterStylesStrategy(6));
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new TitleFilterStylesStrategy('title'));
-RTEFilterStylesStrategyRegistry.register(RTETextBlock.dtoName, new TitleFilterStylesStrategy('subtitle'));
-RTEFilterStylesStrategyRegistry.register(RTETextNode.dtoName, new TitleHeadingNodeFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTETextNode.dtoName, new CodeFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTETextNode.dtoName, new LinkFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTEImageNode.dtoName, new ImageFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTECodeBlock.dtoName, new CodeBlockFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTECodeBlockNode.dtoName, new CodeBlockNodeFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTEListBlock.dtoName, new ListBlockFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListItemBlockFilterStylesStrategy());
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListHeadingItemBlockFilterStylesStrategy(1));
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListHeadingItemBlockFilterStylesStrategy(2));
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListHeadingItemBlockFilterStylesStrategy(3));
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListHeadingItemBlockFilterStylesStrategy(4));
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListHeadingItemBlockFilterStylesStrategy(5));
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListHeadingItemBlockFilterStylesStrategy(6));
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListTitleItemBlockFilterStylesStrategy('title'));
-RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.dtoName, new ListTitleItemBlockFilterStylesStrategy('subtitle'));
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new AlignmentFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTEListBlock.typeName, new AlignmentFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new AlignmentFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTETextNode.typeName, new TextFormatFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new ParagraphFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new HeadingFilterStylesStrategy(1));
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new HeadingFilterStylesStrategy(2));
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new HeadingFilterStylesStrategy(3));
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new HeadingFilterStylesStrategy(4));
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new HeadingFilterStylesStrategy(5));
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new HeadingFilterStylesStrategy(6));
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new TitleFilterStylesStrategy('title'));
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.typeName, new TitleFilterStylesStrategy('subtitle'));
+RTEFilterStylesStrategyRegistry.register(RTETextNode.typeName, new TitleHeadingNodeFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTETextNode.typeName, new CodeFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTETextNode.typeName, new LinkFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTEImageNode.typeName, new ImageFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTECodeBlock.typeName, new CodeBlockFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTECodeBlockNode.typeName, new CodeBlockNodeFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTEListBlock.typeName, new ListBlockFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListItemBlockFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListHeadingItemBlockFilterStylesStrategy(1));
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListHeadingItemBlockFilterStylesStrategy(2));
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListHeadingItemBlockFilterStylesStrategy(3));
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListHeadingItemBlockFilterStylesStrategy(4));
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListHeadingItemBlockFilterStylesStrategy(5));
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListHeadingItemBlockFilterStylesStrategy(6));
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListTitleItemBlockFilterStylesStrategy('title'));
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.typeName, new ListTitleItemBlockFilterStylesStrategy('subtitle'));

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

@@ -112,4 +112,5 @@ export class VegaRTEExtensionRenderer extends VegaRTEBaseRenderer {
     }
   }
 }
+VegaRTEExtensionRenderer.typeName = 'VegaRTEExtensionRenderer';
 VegaRTEExtensionRenderer.REGISTER_REF_FLAG = '__registeredRef__';

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

@@ -21,27 +21,27 @@ export class VegaRTEBlockquoteExtension extends VegaRTEExtension {
   constructor() {
     super();
     this.toolbarButtonRenderer = new RTEBlockquoteToolbarButtonRenderer();
-    this.registerBlockBasicStrategies(RTEBlockquoteBlock.name);
+    this.registerBlockBasicStrategies(RTEBlockquoteBlock.typeName);
     this.registerNode('blockquote', RTEBlockquoteBlock);
     this.registerRenderer('blockquote', RTEBlockquoteBlockRenderer);
     this.registerToolbarButtonRenderer(VegaRTEBlockquoteExtension.TOOLBAR_BUTTON_KEY, this.toolbarButtonRenderer);
     this.registerElementToBlockDTOClassStrategy(new BlockquoteToBlockquoteBlockStrategy());
     // Register filter styles strategy for source edit round-trip.
-    VegaRTEExtension.registerFilterStylesStrategy(RTEBlockquoteBlock.dtoName, new BlockquoteFilterStylesStrategy());
+    VegaRTEExtension.registerFilterStylesStrategy(RTEBlockquoteBlock.typeName, new BlockquoteFilterStylesStrategy());
   }
 }
 (() => {
   const wrapStrategy = new BlockTransformToBlockquoteStrategy();
   // Root container — wrap top-level blocks.
-  VegaRTEExtension.registerActionHandleStrategy(VegaRTEContent.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(VegaRTEContent.typeName, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
   // Table cells (body + header) — wrap is scoped to the closest cell.
   // Other container blocks (code, list item, function) are intentionally
   // not registered, so the toolbar stays disabled inside them.
-  VegaRTEExtension.registerActionHandleStrategy(RTETableCellBlock.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
-  VegaRTEExtension.registerActionHandleStrategy(RTETableHeadCellBlock.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
-  VegaRTEExtension.registerActionHandleStrategy(RTEBlockquoteBlock.name, REMOVE_BLOCKQUOTE, new RemoveBlockquoteStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableCellBlock.typeName, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTETableHeadCellBlock.typeName, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTEBlockquoteBlock.typeName, REMOVE_BLOCKQUOTE, new RemoveBlockquoteStrategy());
   // Enables exiting the blockquote via the keyboard: pressing Enter on an empty
   // trailing paragraph breaks out to a new paragraph after the blockquote.
-  VegaRTEExtension.registerActionHandlerInterceptor(RTETextBlock.name, ModifyContentActionType.INSERT_NEW_PARAGRAPH, new BlockquoteExitOnEnterInterceptor());
+  VegaRTEExtension.registerActionHandlerInterceptor(RTETextBlock.typeName, ModifyContentActionType.INSERT_NEW_PARAGRAPH, new BlockquoteExitOnEnterInterceptor());
 })();
 VegaRTEBlockquoteExtension.TOOLBAR_BUTTON_KEY = 'blockquote';

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/dto/rte-blockquote-block.js

@@ -6,7 +6,6 @@ import { BlockquoteAnnotation } from './blockquote-annotation';
 export class RTEBlockquoteBlock extends RTEBlock {
   constructor(id, options) {
     super(id);
-    this.dtoName = RTEBlockquoteBlock.dtoName;
     this.type = 'blockquote';
     this.children = [];
     const { autoMatchFormat = true } = options !== null && options !== void 0 ? options : {};
@@ -67,4 +66,4 @@ export class RTEBlockquoteBlock extends RTEBlock {
     return Object.assign(Object.assign({}, super.toJSON()), { id: this.id, type: 'blockquote', children: this.children.map((child) => child.toJSON()) });
   }
 }
-RTEBlockquoteBlock.dtoName = 'RTEBlockquoteBlock';
+RTEBlockquoteBlock.typeName = 'RTEBlockquoteBlock';

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/filter-styles-strategies/blockquote-block/blockquote-filter-styles-strategy.js

@@ -24,7 +24,7 @@ export class BlockquoteFilterStylesStrategy extends RTEFilterStylesStrategy {
    * @inheritDoc
    */
   canFilter(blockOrNodeInstance) {
-    return BlockquoteFilterStylesStrategy.isBlockquoteBlock(blockOrNodeInstance.dtoName);
+    return BlockquoteFilterStylesStrategy.isBlockquoteBlock(blockOrNodeInstance.typeName);
   }
   /**
    * @inheritDoc

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

@@ -18,4 +18,5 @@ export class RTEBlockquoteBlockRenderer extends VegaRTEExtensionRenderer {
     return BlockquoteAnnotation.getDefaultCssText();
   }
 }
+RTEBlockquoteBlockRenderer.typeName = 'RTEBlockquoteBlockRenderer';
 export default new RTEBlockquoteBlockRenderer();

package/dist/collection/components/vega-rich-text-editor/extensions/bookmark/action-handler-interceptors/delete-bookmark-before-text-interceptor.js

@@ -0,0 +1,40 @@
+import { ActionHandlerInterceptor, } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
+import { RemoveChildrenAction } from '../../../dto/actions/remove-child-action';
+import { UpdateTextAction } from '../../../dto/actions/update-text-action';
+import { RTETextNode } from '../../../dto/nodes/text-node';
+import { RTEBookmarkNode } from '../bookmark-node';
+/**
+ * Removes a bookmark when Backspace is pressed at the start of its following text node.
+ */
+export class DeleteBookmarkBeforeTextInterceptor extends ActionHandlerInterceptor {
+  /**
+   * @inheritDoc
+   */
+  canIntercept(action, target) {
+    const { startContainerNode, startOffset } = action;
+    if (!(startContainerNode instanceof RTETextNode)) {
+      return false;
+    }
+    const nodeIndex = target.children.indexOf(startContainerNode);
+    return (startContainerNode.parent === target &&
+      nodeIndex > 0 &&
+      target.children[nodeIndex - 1] instanceof RTEBookmarkNode &&
+      (startOffset === 0 ||
+        (startContainerNode.text.length === 1 && startOffset === startContainerNode.text.length)));
+  }
+  /**
+   * @inheritDoc
+   */
+  intercept(_execution, action, target) {
+    const startContainerNode = action.startContainerNode;
+    if (startContainerNode.text.length === 1 && action.startOffset === 1) {
+      startContainerNode.apply(new UpdateTextAction(''));
+      action.previousNode = startContainerNode;
+      return;
+    }
+    const nodeIndex = target.children.indexOf(startContainerNode);
+    const bookmarkNode = target.children[nodeIndex - 1];
+    target.apply(new RemoveChildrenAction(bookmarkNode));
+    action.nextNode = startContainerNode;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/bookmark/action-handler-strategies/insert-bookmark-node-strategy.js

@@ -0,0 +1,20 @@
+import { generateUUID } from '../../../../../utils/misc';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { InsertNodeToNearestRootAction } from '../../../dto/actions/insert-node-to-nearest-root-action';
+import { RTEBookmarkNode } from '../bookmark-node';
+/**
+ * Strategy to handle the insertion of a bookmark node into the nearest root block.
+ */
+export class InsertBookmarkNodeStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, block) {
+    const { rteRange, name } = action;
+    if (rteRange && rteRange.startNode) {
+      const bookmarkNode = new RTEBookmarkNode(generateUUID(), name, block);
+      block.apply(new InsertNodeToNearestRootAction(rteRange, bookmarkNode));
+      action.actionHandleResult = true;
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/bookmark/action-handler-strategies/update-bookmark-name-strategy.js

@@ -0,0 +1,12 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+/**
+ * Strategy to rename an existing bookmark node.
+ */
+export class UpdateBookmarkNameStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, node) {
+    node.name = action.name;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/bookmark/actions/insert-bookmark-node-action.js

@@ -0,0 +1,17 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+export const INSERT_BOOKMARK_NODE = 'INSERT_BOOKMARK_NODE';
+/**
+ * Action to insert a bookmark node at a specified range in the Rich Text Editor.
+ *
+ * @example block.apply(new InsertBookmarkNodeAction(rteRange, 'Rights'));
+ */
+export class InsertBookmarkNodeAction extends ModifyContentAction {
+  constructor(rteRange, name) {
+    super();
+    this.type = INSERT_BOOKMARK_NODE;
+    this.rteRange = null;
+    this.actionHandleResult = false;
+    this.rteRange = rteRange;
+    this.name = name;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/bookmark/actions/update-bookmark-name-action.js

@@ -0,0 +1,14 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+export const UPDATE_BOOKMARK_NAME = 'UPDATE_BOOKMARK_NAME';
+/**
+ * Action to rename an existing bookmark node.
+ *
+ * @example bookmarkNode.apply(new UpdateBookmarkNameAction('Rights'));
+ */
+export class UpdateBookmarkNameAction extends ModifyContentAction {
+  constructor(name) {
+    super();
+    this.type = UPDATE_BOOKMARK_NAME;
+    this.name = name;
+  }
+}