@globalpayments/vega 2.57.1 → 2.59.0

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

@@ -1,21 +1,16 @@
 import { RTEBlock } from './block.abstract';
 import { RTEImageNode } from '../nodes/image-node';
 import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
-import { isNonNullable } from '../../../../types/type-guard';
 import { generateUUID } from '../../../../utils/misc';
 import { ActionHandleStrategyRegistry } from '../action-handle-strategies/action-handle-strategy-registry';
-import { BlockDeleteImageStrategy } from '../action-handle-strategies/modify-content-strategies/block-delete-image-strategy';
 import { BlockMergeNodesStrategy } from '../action-handle-strategies/modify-content-strategies/block-merge-nodes-strategy';
-import { BlockRemoveNodeStrategy } from '../action-handle-strategies/modify-content-strategies/block-remove-node-strategy';
-import { BlockAppendNodesStrategy } from '../action-handle-strategies/modify-content-strategies/block-append-nodes-strategy';
 import { BlockReplaceNodesStrategy } from '../action-handle-strategies/modify-content-strategies/block-replace-nodes-strategy';
 import { BlockSplitWithImageNodeStrategy } from '../action-handle-strategies/modify-content-strategies/block-split-with-image-node-strategy';
-import { ImageInsertNewParagraphStrategy } from '../action-handle-strategies/modify-content-strategies/image-insert-new-paragraph-strategy';
 import { ImageInsertLineBreakStrategy } from '../action-handle-strategies/modify-content-strategies/image-insert-line-break-strategy';
 import { ImageInsertLineBreakWithBlocksStrategy } from '../action-handle-strategies/modify-content-strategies/image-insert-line-break-with-blocks-strategy';
 import { ImageBlockInsertImageStrategy } from '../action-handle-strategies/modify-content-strategies/image-block-insert-image-strategy';
-import { BlockInsertNodesBeforeNodeStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-nodes-before-node-strategy';
-import { BlockInsertNodesAfterNodeStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-nodes-after-node-strategy';
+import { HorizontalAlignmentAnnotationAction } from '../actions/horizontal-alignment-annotation-action';
+import { BlockUpdateHorizontalAlignmentStrategy } from '../action-handle-strategies/apply-annotation-strategies/block-update-horizontal-alignment-strategy';
 /**
  * Image block
  */
@@ -29,19 +24,15 @@ export class RTEImageBlock extends RTEBlock {
    * Converts a VegaRTEImageBlock object into an RTEImageBlock object by mapping nodes and creating annotations.
    *
    * @param {VegaRTEImageBlock} block - The block object to be converted.
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
    * @returns {RTEImageBlock} An instance of `RTEImageBlock`
    */
-  static from(block) {
+  static from(block, options = { autoMatchFormat: true }) {
     const imageBlock = new RTEImageBlock(block.id);
     const { annotations } = block;
-    imageBlock.children = block.nodes.map((image) => RTEImageNode.from(image, imageBlock));
+    imageBlock.children = block.nodes.map((image) => RTEImageNode.from(image, imageBlock, options));
     if (annotations) {
-      Object.entries(annotations).forEach(([type, value]) => {
-        const item = this.createAnnotationEntity(type, value);
-        if (isNonNullable(item)) {
-          imageBlock.annotationMap.set(...item);
-        }
-      });
+      super.convertAnnotationsToMap(imageBlock.annotationMap, annotations);
     }
     return imageBlock;
   }
@@ -51,6 +42,16 @@ export class RTEImageBlock extends RTEBlock {
   toJSON() {
     return Object.assign(Object.assign({}, super.toJSON()), { type: 'image', nodes: this.children.map((node) => node.toJSON()) });
   }
+  /**
+   * @inheritDoc
+   */
+  toHtml() {
+    const attrStr = super.generateAttributeString();
+    const children = this.children.map((node) => node.toHtml()).join('');
+    return super.shouldRenderAsInternalWrapper()
+      ? children
+      : [`<div${attrStr}>`, children, `</div>`].join('');
+  }
   /**
    * @inheritDoc
    */
@@ -87,16 +88,11 @@ export class RTEImageBlock extends RTEBlock {
   }
 }
 (() => {
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_BLOCK_CONTENT, RTEImageBlock.name, new BlockDeleteImageStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.MERGE_TWO_BLOCKS_NODES, RTEImageBlock.name, new BlockMergeNodesStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_CHILD, RTEImageBlock.name, new BlockRemoveNodeStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.APPEND_CHILD_NODES, RTEImageBlock.name, new BlockAppendNodesStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.REPLACE_CHILD_NODES, RTEImageBlock.name, new BlockReplaceNodesStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.SPLIT_BLOCK_WITH_NODE, RTEImageBlock.name, new BlockSplitWithImageNodeStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.BREAK_SINGLE_BLOCK, RTEImageBlock.name, new ImageInsertNewParagraphStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK, RTEImageBlock.name, new ImageInsertLineBreakStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS, RTEImageBlock.name, new ImageInsertLineBreakWithBlocksStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTEImageBlock.name, new ImageBlockInsertImageStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_NODES_BEFORE, RTEImageBlock.name, new BlockInsertNodesBeforeNodeStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_NODES_AFTER, RTEImageBlock.name, new BlockInsertNodesAfterNodeStrategy());
+  ActionHandleStrategyRegistry.register(HorizontalAlignmentAnnotationAction.name, RTEImageBlock.name, new BlockUpdateHorizontalAlignmentStrategy());
 })();

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

@@ -2,44 +2,94 @@ import { RTEBlock } from './block.abstract';
 import { RTEListItemBlock } from './list-item-block';
 import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
 import { ActionHandleStrategyRegistry } from '../action-handle-strategies/action-handle-strategy-registry';
-import { BlockInsertBlocksBeforeStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-blocks-before-strategy';
-import { BlockInsertBlocksAfterStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-blocks-after-strategy';
-import { BlockAppendBlocksStrategy } from '../action-handle-strategies/modify-content-strategies/block-append-blocks-strategy';
-import { ListRemoveListItemStrategy } from '../action-handle-strategies/modify-content-strategies/list-remove-list-item-strategy';
 import { ListTransformToListStrategy } from '../action-handle-strategies/modify-content-strategies/list-transform-to-list-strategy';
 import { ListTransformToParagraphStrategy } from '../action-handle-strategies/modify-content-strategies/list-transform-to-paragraph-strategy';
 import { ListInsertImageStrategy } from '../action-handle-strategies/modify-content-strategies/list-insert-image-strategy';
+import { BlockAnnotationTypeEnum } from '../annotations/block-annotation.abstract';
+import { ListAnnotation } from '../annotations/list-annotation';
+import { isNonNullable } from '../../../../types/type-guard';
+import { CustomAttributeAnnotation } from '../annotations/custom-attribute-annotation';
+import { CustomClassAnnotation } from '../annotations/custom-class-annotation';
+import { CustomStyleAnnotation } from '../annotations/custom-style-annotation';
 /**
  * List block
  */
 export class RTEListBlock extends RTEBlock {
-  constructor(id, type) {
+  constructor(id, type, options) {
     super(id);
     this.type = 'bullet-list';
     this.children = [];
     this.type = type;
+    const { autoMatchFormat } = options || { autoMatchFormat: true };
+    if (autoMatchFormat) {
+      this.annotationMap.set(BlockAnnotationTypeEnum.LIST, new ListAnnotation());
+    }
   }
   /**
    * Converts a VegaRTEListBlock object to an RTEListBlock
    *
    * @param {VegaRTEListBlock} block - Converts a `VegaRTEListBlock` object into an `RTEListBlock`.
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
    * @returns {RTEListBlock} Return an instance of `RTEListBlock`
    */
-  static from(block) {
-    const listBlock = new RTEListBlock(block.id, block.type);
+  static from(block, options = { autoMatchFormat: true }) {
+    const listBlock = new RTEListBlock(block.id, block.type, options);
+    const { annotations } = block;
+    if (annotations) {
+      Object.entries(annotations).forEach(([type, value]) => {
+        const item = this.createAnnotationEntity(type, value);
+        if (isNonNullable(item)) {
+          listBlock.annotationMap.set(...item);
+        }
+      });
+    }
     listBlock.children = block.blocks.map((item) => {
-      const listItemBlock = RTEListItemBlock.from(item);
+      const listItemBlock = RTEListItemBlock.from(item, options);
       listItemBlock.parent = listBlock;
       return listItemBlock;
     });
     return listBlock;
   }
+  /**
+   * The function `createAnnotationEntity` creates a block annotation entity based on the provided type
+   * and value.
+   *
+   * @param {keyof VegaRTEBlockAnnotations} type - The `type` parameter is a key of the `VegaRTEBlockAnnotations` enum, which specifies
+   * the type of annotation entity to create.
+   * @param {unknown} value - The `value` parameter in the `createAnnotationEntity` function is the value
+   * that will be used to create the annotation entity. It can be of any type depending on the specific
+   * annotation being created.
+   * @returns {Nullable<BlockAnnotationsEntity>} The `createAnnotationEntity` function returns a nullable tuple containing a
+   * `BlockAnnotationTypeEnum` and a `BlockAnnotation` object.
+   */
+  static createAnnotationEntity(type, value) {
+    switch (type) {
+      case 'customAttribute':
+        return CustomAttributeAnnotation.from(value);
+      case 'customClass':
+        return CustomClassAnnotation.from(value);
+      case 'customStyle':
+        return CustomStyleAnnotation.from(value);
+    }
+  }
   /**
    * @inheritDoc
    */
   toJSON() {
     return Object.assign(Object.assign({}, super.toJSON()), { id: this.id, type: this.type, blocks: this.children.map((block) => block.toJSON()) });
   }
+  /**
+   * @inheritDoc
+   */
+  toHtml() {
+    const BlockTag = this.getBlockTag();
+    const attrStr = super.generateAttributeString();
+    return [
+      `<${BlockTag}${attrStr}>`,
+      this.children.map((block) => block.toHtml()).join(''),
+      `</${BlockTag}>`,
+    ].join('');
+  }
   /**
    * @inheritDoc
    */
@@ -66,12 +116,16 @@ export class RTEListBlock extends RTEBlock {
     clonedListBlock.parent = this.parent;
     return clonedListBlock;
   }
+  /**
+   * Returns the block tag based on the type of the list block.
+   *
+   * @returns {RTEListBlockTagType} - The block tag for the list block, either 'ol' or 'ul'.
+   */
+  getBlockTag() {
+    return this.type === 'number-list' ? 'ol' : 'ul';
+  }
 }
 (() => {
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_CHILD, RTEListBlock.name, new ListRemoveListItemStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_BLOCKS_BEFORE, RTEListBlock.name, new BlockInsertBlocksBeforeStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_BLOCKS_AFTER, RTEListBlock.name, new BlockInsertBlocksAfterStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.APPEND_CHILD_NODES, RTEListBlock.name, new BlockAppendBlocksStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.TRANSFORM_LIST_BLOCK, RTEListBlock.name, new ListTransformToListStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.TRANSFORM_PARAGRAPH_BLOCK, RTEListBlock.name, new ListTransformToParagraphStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTEListBlock.name, new ListInsertImageStrategy());

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

@@ -1,30 +1,25 @@
 import { RTETextNode } from '../nodes/text-node';
 import { RTEListBlock } from './list-block';
 import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
-import { AppendChildNodesAction } from '../actions/append-child-nodes-action';
+import { AppendChildrenAction } from '../actions/append-child-nodes-action';
 import { generateUUID } from '../../../../utils/misc';
 import { RTETextBlock } from './text-block';
-import { isNonNullable } from '../../../../types/type-guard';
 import { ActionHandleStrategyRegistry } from '../action-handle-strategies/action-handle-strategy-registry';
-import { ListItemDeleteTextContentStrategy } from '../action-handle-strategies/modify-content-strategies/list-item-delete-text-content-strategy';
 import { BlockInsertLineBreakStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-line-break-strategy';
 import { BlockInsertLineBreakWithBlocksStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-line-break-with-blocks-strategy';
-import { ListItemRemoveNodeStrategy } from '../action-handle-strategies/modify-content-strategies/list-item-remove-node-strategy';
 import { ListItemRemoveNestListStrategy } from '../action-handle-strategies/modify-content-strategies/list-item-remove-nest-list-strategy';
-import { BlockAppendNodesStrategy } from '../action-handle-strategies/modify-content-strategies/block-append-nodes-strategy';
 import { BlockSplitWithTextNodeStrategy } from '../action-handle-strategies/modify-content-strategies/block-split-with-text-node-strategy';
 import { BlockReplaceNodesStrategy } from '../action-handle-strategies/modify-content-strategies/block-replace-nodes-strategy';
 import { ListItemReplaceNestListStrategy } from '../action-handle-strategies/modify-content-strategies/list-item-replace-nest-list-strategy';
 import { BlockMergeNodesStrategy } from '../action-handle-strategies/modify-content-strategies/block-merge-nodes-strategy';
-import { ListItemInsertNewParagraphStrategy } from '../action-handle-strategies/modify-content-strategies/list-item-insert-new-paragraph-strategy';
 import { ListItemInsertImageStrategy } from '../action-handle-strategies/modify-content-strategies/list-item-insert-image-strategy';
-import { BlockInsertNodesBeforeNodeStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-nodes-before-node-strategy';
+import { isNonNullable } from '../../../../types/type-guard';
 /**
  * List item block
  */
 export class RTEListItemBlock extends RTETextBlock {
-  constructor(id, nestList) {
-    super(id, 'list-item');
+  constructor(id, nestList, options) {
+    super(id, 'list-item', options);
     /**
      * TODO: Refactor the list item properties children and nestList, merge two properties together.
      *
@@ -38,11 +33,12 @@ export class RTEListItemBlock extends RTETextBlock {
    * Converts a VegaRTEListItemBlock object to an RTEListItemBlock
    *
    * @param {VegaRTEListBlock} block - Converts a `VegaRTEListItemBlock` object into an `RTEListItemBlock`.
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
    * @returns {RTEListItemBlock} Return an instance of `RTEListItemBlock`
    */
-  static from(block) {
-    const listItemBlock = new RTEListItemBlock(block.id);
-    listItemBlock.children = block.nodes.map((richText) => RTETextNode.from(richText, listItemBlock));
+  static from(block, options = { autoMatchFormat: true }) {
+    const listItemBlock = new RTEListItemBlock(block.id, undefined, options);
+    listItemBlock.children = block.nodes.map((richText) => RTETextNode.from(richText, listItemBlock, options));
     if (block.children) {
       listItemBlock.nestList = block.children.map((child) => {
         const listBlock = RTEListBlock.from(child);
@@ -68,13 +64,24 @@ export class RTEListItemBlock extends RTETextBlock {
     var _a;
     return Object.assign(Object.assign({}, super.toJSON()), { type: 'list-item', children: (_a = this.nestList) === null || _a === void 0 ? void 0 : _a.map((block) => block.toJSON()) });
   }
+  /**
+   * @inheritDoc
+   */
+  toHtml() {
+    const attrStr = super.generateAttributeString();
+    return [
+      `<li${attrStr}>`,
+      this.children.map((node) => node.toHtml()).join(''),
+      `</li>`,
+    ].join('');
+  }
   /**
    * @inheritDoc
    */
   cloneWithNodes(nodes) {
     const block = new RTEListItemBlock(generateUUID());
     block.children = [];
-    block.apply(new AppendChildNodesAction(nodes));
+    block.apply(new AppendChildrenAction(nodes));
     return block;
   }
   /**
@@ -117,17 +124,12 @@ export class RTEListItemBlock extends RTETextBlock {
   }
 }
 (() => {
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_BLOCK_CONTENT, RTEListItemBlock.name, new ListItemDeleteTextContentStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK, RTEListItemBlock.name, new BlockInsertLineBreakStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS, RTEListItemBlock.name, new BlockInsertLineBreakWithBlocksStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_CHILD, RTEListItemBlock.name, new ListItemRemoveNodeStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_NEST_LIST, RTEListItemBlock.name, new ListItemRemoveNestListStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.APPEND_CHILD_NODES, RTEListItemBlock.name, new BlockAppendNodesStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.SPLIT_BLOCK_WITH_NODE, RTEListItemBlock.name, new BlockSplitWithTextNodeStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.REPLACE_CHILD_NODES, RTEListItemBlock.name, new BlockReplaceNodesStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.REPLACE_NEST_LIST, RTEListItemBlock.name, new ListItemReplaceNestListStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.MERGE_TWO_BLOCKS_NODES, RTEListItemBlock.name, new BlockMergeNodesStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.BREAK_SINGLE_BLOCK, RTEListItemBlock.name, new ListItemInsertNewParagraphStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTEListItemBlock.name, new ListItemInsertImageStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_NODES_BEFORE, RTEListItemBlock.name, new BlockInsertNodesBeforeNodeStrategy());
 })();

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

@@ -1,8 +1,6 @@
-import { RTETextNode } from '../nodes/text-node';
-import { isNonNullable } from '../../../../types/type-guard';
 import { TextStyleAnnotation } from '../annotations/text-style-annotation';
 import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
-import { AppendChildNodesAction } from '../actions/append-child-nodes-action';
+import { AppendChildrenAction } from '../actions/append-child-nodes-action';
 import { RTEBlock } from './block.abstract';
 import { TextStyleAnnotationAction } from '../actions/text-style-annotation-action';
 import { NodeAnnotationTypeEnum } from '../annotations/node-annotation.abstract';
@@ -12,50 +10,61 @@ import { generateUUID } from '../../../../utils/misc';
 import { ActionHandleStrategyRegistry } from '../action-handle-strategies/action-handle-strategy-registry';
 import { BlockUpdateTextStyleStrategy } from '../action-handle-strategies/apply-annotation-strategies/block-update-text-style-strategy';
 import { BlockUpdateLinkGroupStrategy } from '../action-handle-strategies/apply-annotation-strategies/block-update-link-group-strategy';
-import { BlockRemoveNodeStrategy } from '../action-handle-strategies/modify-content-strategies/block-remove-node-strategy';
-import { BlockAppendNodesStrategy } from '../action-handle-strategies/modify-content-strategies/block-append-nodes-strategy';
 import { BlockSplitWithTextNodeStrategy } from '../action-handle-strategies/modify-content-strategies/block-split-with-text-node-strategy';
 import { BlockReplaceNodesStrategy } from '../action-handle-strategies/modify-content-strategies/block-replace-nodes-strategy';
 import { BlockMergeNodesStrategy } from '../action-handle-strategies/modify-content-strategies/block-merge-nodes-strategy';
-import { BlockInsertNewParagraphStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-new-paragraph-strategy';
 import { BlockInsertLineBreakStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-line-break-strategy';
 import { BlockInsertLineBreakWithBlocksStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-line-break-with-blocks-strategy';
-import { BlockDeleteTextContentStrategy } from '../action-handle-strategies/modify-content-strategies/block-delete-text-content-strategy';
 import { BlockInsertImageIntoTextStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-image-into-text-strategy';
-import { BlockInsertNodesBeforeNodeStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-nodes-before-node-strategy';
 import { BlockTransformToListStrategy } from '../action-handle-strategies/modify-content-strategies/block-transform-to-list-strategy';
+import { InternalAnnotationTypeEnum } from '../annotations/annotation.abstract';
+import { isNonNullable } from '../../../../types/type-guard';
+import { HorizontalAlignmentAnnotationAction } from '../actions/horizontal-alignment-annotation-action';
+import { BlockUpdateHorizontalAlignmentStrategy } from '../action-handle-strategies/apply-annotation-strategies/block-update-horizontal-alignment-strategy';
+import { BlockUpdateIndentStrategy } from '../action-handle-strategies/apply-annotation-strategies/block-update-indent-strategy';
+import { IndentAnnotationAction } from '../actions/indent-annotation-action';
+import RTEDTOClassManager from '../../../../helpers/rte-manager/dto-class-manager';
+import { BlockUnlinkLinkGroupStrategy } from '../action-handle-strategies/modify-content-strategies/block-unlink-link-group-strategy';
 /**
  * Text block
  */
 export class RTETextBlock extends RTEBlock {
-  constructor(id, type) {
+  constructor(id, type, options) {
     super(id);
     this.children = [];
     this.type = type;
-    if (RTETextBlock.isAcceptableTextStyle(type)) {
-      this.annotationMap = new Map([TextStyleAnnotation.from(type)]);
-    }
-    else {
-      this.annotationMap = new Map([TextStyleAnnotation.from('paragraph')]);
+    const { autoMatchFormat } = options || { autoMatchFormat: true };
+    if (autoMatchFormat) {
+      if (RTETextBlock.isAcceptableTextStyle(type)) {
+        this.annotationMap = new Map([TextStyleAnnotation.from(type)]);
+      }
+      else {
+        this.annotationMap = new Map([TextStyleAnnotation.from('paragraph')]);
+      }
     }
   }
   /**
    * Converts a VegaRTETextBlock into an RTETextBlock.
    *
    * @param {VegaRTETextBlock} block - The block object
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
    * @returns {RTETextBlock} A RTETextBlock class
    */
-  static from(block) {
-    const textBlock = new RTETextBlock(block.id, block.type);
-    const { annotations } = block;
-    textBlock.children = block.nodes.map((richText) => RTETextNode.from(richText, textBlock));
+  static from(block, options = { autoMatchFormat: true }) {
+    var _a, _b;
+    const textBlock = new RTETextBlock(block.id, block.type, options);
+    const annotations = options.autoMatchFormat
+      ? Object.assign(Object.assign({}, block.annotations), { textStyle: (_b = (_a = block.annotations) === null || _a === void 0 ? void 0 : _a.textStyle) !== null && _b !== void 0 ? _b : textBlock.type }) : block.annotations;
+    textBlock.children = block.nodes
+      .map((richText) => {
+      const NodeClass = RTEDTOClassManager.getRTENodeClass(richText.type);
+      if (NodeClass) {
+        return NodeClass.from(richText, textBlock, options);
+      }
+    })
+      .filter(isNonNullable);
     if (annotations) {
-      Object.entries(annotations).forEach(([type, value]) => {
-        const item = this.createAnnotationEntity(type, value);
-        if (isNonNullable(item)) {
-          textBlock.annotationMap.set(...item);
-        }
-      });
+      super.convertAnnotationsToMap(textBlock.annotationMap, annotations);
     }
     return textBlock;
   }
@@ -68,7 +77,7 @@ export class RTETextBlock extends RTEBlock {
    * @param {unknown} value - The `value` parameter in the `createAnnotationEntity` function is the value
    * that will be used to create the annotation entity. It can be of any type depending on the specific
    * annotation being created.
-   * @returns {Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>} The `createAnnotationEntity` function returns a nullable tuple containing a
+   * @returns {Nullable<BlockAnnotationsEntity>} The `createAnnotationEntity` function returns a nullable tuple containing a
    * `BlockAnnotationTypeEnum` and a `BlockAnnotation` object.
    */
   static createAnnotationEntity(type, value) {
@@ -125,16 +134,31 @@ export class RTETextBlock extends RTEBlock {
   toJSON() {
     return Object.assign(Object.assign({}, super.toJSON()), { type: this.type, nodes: this.children.map((node) => node.toJSON()) });
   }
+  /**
+   * @inheritDoc
+   */
+  toHtml(options) {
+    const BlockTag = this.getBlockTag();
+    const attrStr = super.generateAttributeString();
+    const linkGroupAnnotation = this.getAnnotationByType(InternalAnnotationTypeEnum.LINK_GROUP);
+    let nodesHtml = this.children.map((node) => node.toHtml()).join('');
+    if (linkGroupAnnotation && this.children.length > 0) {
+      nodesHtml = this.generateLinkHtml(linkGroupAnnotation, nodesHtml, options);
+    }
+    return super.shouldRenderAsInternalWrapper()
+      ? nodesHtml
+      : [`<${BlockTag}${attrStr}>`, nodesHtml, `</${BlockTag}>`].join('');
+  }
   /**
    * Clone the nodes to a new block
    *
    * @param {RTEBlock} nodes - The nodes will be copied
-   * @returns {RTEBlock} New block
+   * @returns {RTETextBlock} New block
    */
   cloneWithNodes(nodes) {
     const block = new RTETextBlock(generateUUID(), this.type);
-    block.children = [];
-    block.apply(new AppendChildNodesAction(nodes));
+    block.annotationMap = super.cloneAnnotations();
+    block.apply(new AppendChildrenAction(nodes));
     return block;
   }
   /**
@@ -164,12 +188,31 @@ export class RTETextBlock extends RTEBlock {
     return this.children[this.children.length - 1];
   }
   /**
-   * Create new empty paragraph.
+   * Get the HTML tag for the block based on its type.
    *
-   * @returns {RTETextBlock} Paragraph.
+   * @returns {RTETextBlockTagType} The HTML tag for the block.
    */
-  createNewParagraph() {
-    return new RTETextBlock(generateUUID(), 'paragraph');
+  getBlockTag() {
+    switch (this.type) {
+      case 'title':
+      case 'subtitle':
+        return `div`;
+      case 'heading-1':
+        return `h1`;
+      case 'heading-2':
+        return `h2`;
+      case 'heading-3':
+        return `h3`;
+      case 'heading-4':
+        return `h4`;
+      case 'heading-5':
+        return `h5`;
+      case 'heading-6':
+        return `h6`;
+      case 'paragraph':
+      default:
+        return 'p';
+    }
   }
   /**
    * @inheritDoc
@@ -180,20 +223,56 @@ export class RTETextBlock extends RTEBlock {
       strategy.execute(action, this);
     }
   }
+  /**
+   * Generate Link Html
+   *
+   * @param {LinkGroupAnnotation} linkGroupAnnotation - linkGroupAnnotation
+   * @param {string} nodesHtml - The nodes html
+   * @param {VegaRTETransformOptions} options - options
+   * @returns {string} link html
+   */
+  generateLinkHtml(linkGroupAnnotation, nodesHtml, options) {
+    nodesHtml = '';
+    let linkGroupNodes = [];
+    for (let i = 0; i < this.children.length; i++) {
+      const currentLinkAnnotation = this.children[i].getAnnotationByType(NodeAnnotationTypeEnum.LINK);
+      const nextLinkAnnotation = this.children[i + 1]
+        ? this.children[i + 1].getAnnotationByType(NodeAnnotationTypeEnum.LINK)
+        : null;
+      if (currentLinkAnnotation) {
+        linkGroupNodes.push(this.children[i]);
+        if (!nextLinkAnnotation ||
+          currentLinkAnnotation.link.groupKey !== nextLinkAnnotation.link.groupKey) {
+          const linkAttributes = linkGroupAnnotation.toString(currentLinkAnnotation, {
+            standalone: true,
+            autoMatchFormat: options === null || options === void 0 ? void 0 : options.autoMatchFormat,
+          });
+          nodesHtml += [
+            `<a${linkAttributes ? ` ${linkAttributes}` : ''}>`,
+            linkGroupNodes.map((linkNode) => linkNode.toHtml()).join(''),
+            `</a>`,
+          ].join('');
+          linkGroupNodes = [];
+        }
+      }
+      else {
+        nodesHtml += this.children[i].toHtml();
+      }
+    }
+    return nodesHtml;
+  }
 }
 (() => {
   ActionHandleStrategyRegistry.register(TextStyleAnnotationAction.name, RTETextBlock.name, new BlockUpdateTextStyleStrategy());
+  ActionHandleStrategyRegistry.register(HorizontalAlignmentAnnotationAction.name, RTETextBlock.name, new BlockUpdateHorizontalAlignmentStrategy());
+  ActionHandleStrategyRegistry.register(IndentAnnotationAction.name, RTETextBlock.name, new BlockUpdateIndentStrategy());
   ActionHandleStrategyRegistry.register(LinkGroupAnnotationAction.name, RTETextBlock.name, new BlockUpdateLinkGroupStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_CHILD, RTETextBlock.name, new BlockRemoveNodeStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.APPEND_CHILD_NODES, RTETextBlock.name, new BlockAppendNodesStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.UNLINK_LINK_GROUP, RTETextBlock.name, new BlockUnlinkLinkGroupStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.SPLIT_BLOCK_WITH_NODE, RTETextBlock.name, new BlockSplitWithTextNodeStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.REPLACE_CHILD_NODES, RTETextBlock.name, new BlockReplaceNodesStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.MERGE_TWO_BLOCKS_NODES, RTETextBlock.name, new BlockMergeNodesStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.BREAK_SINGLE_BLOCK, RTETextBlock.name, new BlockInsertNewParagraphStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK, RTETextBlock.name, new BlockInsertLineBreakStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS, RTETextBlock.name, new BlockInsertLineBreakWithBlocksStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_BLOCK_CONTENT, RTETextBlock.name, new BlockDeleteTextContentStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTETextBlock.name, new BlockInsertImageIntoTextStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_NODES_BEFORE, RTETextBlock.name, new BlockInsertNodesBeforeNodeStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.TRANSFORM_LIST_BLOCK, RTETextBlock.name, new BlockTransformToListStrategy());
 })();