@globalpayments/vega 2.38.0 → 2.39.0

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

@@ -1,15 +1,24 @@
 import { RTETextNode } from '../nodes/text-node';
 import { RTEListBlock } from './list-block';
 import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
-import { RemoveChildAction } from '../actions/remove-child-action';
 import { AppendChildNodesAction } from '../actions/append-child-nodes-action';
 import { generateUUID } from '../../../../utils/misc';
-import { SplitBlockWithNodeAction } from '../actions/split-block-with-node-action';
 import { RTETextBlock } from './text-block';
-import { InsertBlocksAfterAction } from '../actions/insert-blocks-after-block';
-import { InsertBlocksBeforeAction } from '../actions/insert-blocks-before-block';
 import { isNonNullable } from '../../../../types/type-guard';
-import { NodeAnnotationTypeEnum } from '../annotations/node-annotation.abstract';
+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';
 /**
  * List item block
  */
@@ -84,186 +93,26 @@ export class RTEListItemBlock extends RTETextBlock {
     return super.getLastNode();
   }
   /**
-   * Apply a modify action to block
+   * Create a new list item block.
    *
-   * @param {ModifyContentAction} action - Modify action
+   * @returns {RTEListItemBlock} - A list item block.
    */
-  doModifyActionApply(action) {
-    switch (action.type) {
-      case ModifyContentActionType.DELETE_CHILD:
-        this.removeListChildNode(action);
-        break;
-      case ModifyContentActionType.DELETE_NEST_LIST:
-        this.removeNestList(action);
-        break;
-      case ModifyContentActionType.APPEND_CHILD_NODES:
-        this.appendChildNodes(action.entityToBeAppended);
-        break;
-      case ModifyContentActionType.CLEAR_CHILD_NODES:
-        this.nodes = [];
-        break;
-      case ModifyContentActionType.SPLIT_BLOCK_WITH_NODE:
-        this.splitListItemBlock(action);
-        break;
-      case ModifyContentActionType.REPLACE_CHILD_NODES:
-        this.nodes = [];
-        this.appendChildNodes(action.newChildNodes);
-        break;
-      case ModifyContentActionType.REPLACE_NEST_LIST:
-        this.replaceNestList(action.newList);
-        break;
-      case ModifyContentActionType.MERGE_TWO_BLOCKS_NODES:
-        this.mergeTwoBlocksNodes(action.blockNeedToBeMerged);
-        break;
-      case ModifyContentActionType.BREAK_SINGLE_BLOCK:
-        action.newBlock = this.breakSingleListItemBlock(action.startContainerNode, action.startOffset);
-        break;
-      case ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK:
-        action.lineBreakNode = this.lineBreakSingleBlock(action.startContainerNode, action.startOffset);
-        break;
-      case ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS:
-        action.lineBreakNode = this.lineBreakMultipleBlocks(action.selectedBlocks);
-        break;
-      case ModifyContentActionType.DELETE_BLOCK_CONTENT:
-        this.deleteListNodeContent(action);
-        break;
-      case ModifyContentActionType.INSERT_IMAGE_TO_BLOCK:
-        this.parent.apply(action);
-        break;
-      case ModifyContentActionType.INSERT_NODES_BEFORE:
-        this.replaceNodeWithNodes(action.referNode, [
-          ...action.nodesToBeInserted,
-          action.referNode,
-        ]);
-        break;
-    }
-  }
-  /**
-   * Remove the list child node
-   *
-   * @param {RemoveChildAction} action - Modify action
-   */
-  removeListChildNode(action) {
-    this.nodes = this.nodes.filter((node) => node !== action.entityToBeRemoved);
-    if (this.nodes.length === 0 && (!this.children || !this.children.length)) {
-      this.parent.apply(new RemoveChildAction(this));
-    }
-  }
-  /**
-   * Remove the nest list
-   *
-   * @param {RemoveNestListAction} action - Modify action
-   */
-  removeNestList(action) {
-    if (this.children) {
-      if (this.children.length > 1) {
-        this.children = this.children.filter((child) => child !== action.nestListBlockToBeRemoved);
-      }
-      else {
-        this.children = undefined;
-      }
-    }
-  }
-  /**
-   * Iterates through a list of RTEListBlock and sets their parent property to the current object, then replaces the children property with the new list.
-   *
-   * @param {RTEListBlock[]} newList - new list that you want to replace the existing children of the current object with.
-   */
-  replaceNestList(newList) {
-    newList.forEach((listBlock) => {
-      listBlock.parent = this;
-    });
-    this.children = newList;
-  }
-  /**
-   * Split list item block
-   *
-   * @param {SplitBlockWithNodeAction} action - Modify action
-   */
-  splitListItemBlock(action) {
-    action.newBlock = this.splitTextNodeBlock(action.splitPointNode, action.startOffsetOfNode);
-  }
-  /**
-   * Breaks a single list item block at a specific position.
-   *
-   * @param {RTETextNode} splitNode - The node that needs to be split within a list item block.
-   * @param {number} startOffsetOfNode - The index within the `splitNode` where the break operation should occur.
-   * @returns {Nullable<RTEBlock>} Returns either a new `RTEListItemBlock` if the caret
-   * position is at the end of the `splitNode`, or it returns the result of splitting the block at the
-   * caret position if it is neither at the start nor at the end.
-   */
-  breakSingleListItemBlock(splitNode, startOffsetOfNode) {
-    const newListItem = new RTEListItemBlock(generateUUID());
-    const newBreakNode = this.copyInlineStyleToNewNode(splitNode);
-    newListItem.apply(new AppendChildNodesAction([newBreakNode]));
-    if (this.isCaretPositionAtEnd(splitNode, startOffsetOfNode)) {
-      return this.breakListItemAtEnd(newListItem);
-    }
-    else if (this.isCaretPositionAtStart(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksBeforeAction(this, newListItem));
-    }
-    else {
-      const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
-      this.apply(splitBlockAction);
-      return splitBlockAction.newBlock;
-    }
-    return newListItem;
-  }
-  /**
-   * Breaks a list item at the end and handles the insertion of a new list item or paragraph accordingly.
-   *
-   * @param {RTEListItemBlock} newListItem - Item that represents a new list item to be added to the existing list.
-   * @returns {RTEBlock} Returns a `RTEBlock`.
-   */
-  breakListItemAtEnd(newListItem) {
-    const lastItem = this.parent.blocks[this.parent.blocks.length - 1];
-    const currentItemIsEmpty = this.nodes.length === 1 && this.nodes[0].isEmpty();
-    if (this === lastItem && currentItemIsEmpty) {
-      const parentParent = this.parent.parent;
-      if (parentParent['type'] !== 'list-item') {
-        const newParagraph = RTETextBlock.from({
-          id: generateUUID(),
-          type: 'paragraph',
-          nodes: [],
-        });
-        newParagraph.apply(new AppendChildNodesAction(newListItem.nodes));
-        parentParent.apply(new InsertBlocksAfterAction(this.parent, newParagraph));
-        this.parent.apply(new RemoveChildAction(this));
-        return newParagraph;
-      }
-      else {
-        parentParent.parent.apply(new InsertBlocksAfterAction(parentParent, newListItem));
-        this.parent.apply(new RemoveChildAction(this));
-      }
-    }
-    else {
-      this.parent.apply(new InsertBlocksAfterAction(this, newListItem));
-    }
-    return newListItem;
-  }
-  /**
-   * Delete list node content
-   *
-   * @param {DeleteBlockContentAction} action - Modify action
-   */
-  deleteListNodeContent(action) {
-    const startContainerNode = action.startContainerNode;
-    const listBlock = startContainerNode.parentBlock.parent;
-    this.deleteNodeContent(action);
-    if (listBlock.blocks.length === 0) {
-      listBlock.parent.apply(new RemoveChildAction(listBlock));
-    }
-  }
-  /**
-   * Copy the inline style to new node
-   *
-   * @param {RTETextNode} needCopedNode - The node that needed to be copied to
-   * @returns {RTETextNode} Returns a `RTETextNode`.
-   */
-  copyInlineStyleToNewNode(needCopedNode) {
-    const textNode = needCopedNode.cloneWithText('');
-    // The link annotation doesn't need to inherit
-    textNode.annotationMap.delete(NodeAnnotationTypeEnum.LINK);
-    return textNode;
+  createNewListItem() {
+    return new RTEListItemBlock(generateUUID());
   }
 }
+(() => {
+  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

@@ -2,23 +2,28 @@ 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 { RemoveChildAction } from '../actions/remove-child-action';
 import { AppendChildNodesAction } from '../actions/append-child-nodes-action';
 import { RTEBlock } from './block.abstract';
-import { InternalAnnotationTypeEnum } from '../annotations/annotation.abstract';
 import { TextStyleAnnotationAction } from '../actions/text-style-annotation-action';
-import { BoldAnnotationAction } from '../actions/bold-annotation-action';
 import { NodeAnnotationTypeEnum } from '../annotations/node-annotation.abstract';
 import { LinkAnnotationAction } from '../actions/link-annotation-action';
 import { LinkGroupAnnotationAction } from '../actions/link-group-annotation-action';
-import { SplitBlockWithNodeAction } from '../actions/split-block-with-node-action';
 import { generateUUID } from '../../../../utils/misc';
-import { ReplaceChildNodesAction } from '../actions/replace-child-nodes-action';
-import { MergeTwoBlocksNodesAction } from '../actions/merge-two-blocks-nodes-action';
-import { InsertBlocksAfterAction } from '../actions/insert-blocks-after-block';
-import { InsertBlocksBeforeAction } from '../actions/insert-blocks-before-block';
-import { UpdateTextAction } from '../actions/update-text-action';
-import { DeleteNodeAnnotationAction } from '../actions/delete-node-annotation-action';
+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';
 /**
  * Text block
  */
@@ -135,353 +140,36 @@ export class RTETextBlock extends RTEBlock {
     return this.nodes[this.nodes.length - 1];
   }
   /**
-   * @inheritDoc
-   */
-  doAnnotationActionApply(action) {
-    if (action instanceof TextStyleAnnotationAction) {
-      if (this.type !== 'list-item') {
-        this.type = action.textStyle;
-      }
-      if (action.bold) {
-        this.nodes.forEach((node) => {
-          const boldAnnotationAction = new BoldAnnotationAction(true);
-          boldAnnotationAction.doSplit = false;
-          node.apply(boldAnnotationAction);
-        });
-      }
-      else {
-        this.nodes.forEach((node) => {
-          node.apply(new DeleteNodeAnnotationAction(NodeAnnotationTypeEnum.BOLD));
-        });
-      }
-      return;
-    }
-    if (action instanceof LinkGroupAnnotationAction) {
-      const linkGroupAnnotation = this.getAnnotationByType(InternalAnnotationTypeEnum.LINK_GROUP);
-      if (linkGroupAnnotation) {
-        const linkGroup = linkGroupAnnotation.linkGroups.get(action.groupKey);
-        linkGroupAnnotation.linkGroups.set(action.groupKey, [...linkGroup, ...action.nodes]);
-        this.annotationMap.set(InternalAnnotationTypeEnum.LINK_GROUP, linkGroupAnnotation);
-      }
-      return;
-    }
-  }
-  /**
-   * Apply a modify action to block
-   *
-   * @param {ModifyContentAction} action - Modify action
-   */
-  doModifyActionApply(action) {
-    switch (action.type) {
-      case ModifyContentActionType.DELETE_CHILD:
-        this.removeChildNode(action);
-        break;
-      case ModifyContentActionType.APPEND_CHILD_NODES:
-        this.appendChildNodes(action.entityToBeAppended);
-        break;
-      case ModifyContentActionType.CLEAR_CHILD_NODES:
-        this.nodes = [];
-        break;
-      case ModifyContentActionType.SPLIT_BLOCK_WITH_NODE:
-        action.newBlock = this.splitTextNodeBlock(action.splitPointNode, action.startOffsetOfNode);
-        break;
-      case ModifyContentActionType.REPLACE_CHILD_NODES:
-        this.nodes = [];
-        this.appendChildNodes(action.newChildNodes);
-        break;
-      case ModifyContentActionType.MERGE_TWO_BLOCKS_NODES:
-        this.mergeTwoBlocksNodes(action.blockNeedToBeMerged);
-        break;
-      case ModifyContentActionType.BREAK_SINGLE_BLOCK:
-        action.newBlock = this.breakSingleTextBlock(action.startContainerNode, action.startOffset);
-        break;
-      case ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK:
-        action.lineBreakNode = this.lineBreakSingleBlock(action.startContainerNode, action.startOffset);
-        break;
-      case ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS:
-        action.lineBreakNode = this.lineBreakMultipleBlocks(action.selectedBlocks);
-        break;
-      case ModifyContentActionType.TRANSFORM_LIST_BLOCK:
-        this.convertParagraphToList(action);
-        break;
-      case ModifyContentActionType.DELETE_BLOCK_CONTENT:
-        this.deleteNodeContent(action);
-        break;
-      case ModifyContentActionType.INSERT_IMAGE_TO_BLOCK:
-        this.insertImage(action);
-        break;
-      case ModifyContentActionType.INSERT_NODES_BEFORE:
-        this.replaceNodeWithNodes(action.referNode, [
-          ...action.nodesToBeInserted,
-          action.referNode,
-        ]);
-        break;
-    }
-  }
-  /**
-   * Splits a text node at a specified offset within a block of nodes and returns a new block with the split nodes.
-   *
-   * @param {RTETextNode} splitNode - The text node that will be split
-   * @param {number} startOffsetOfNode - The index at which will split the text content of the `splitNode`.
-   * @returns {Nullable<RTEBlock>} return either an RTEBlock object or null.
-   */
-  splitTextNodeBlock(splitNode, startOffsetOfNode) {
-    if (splitNode) {
-      const beforeText = splitNode.text.slice(0, startOffsetOfNode);
-      const afterText = splitNode.text.slice(startOffsetOfNode);
-      const nodesSplitIndex = this.nodes.indexOf(splitNode);
-      if (nodesSplitIndex > -1) {
-        const beforeNodes = this.nodes.slice(0, nodesSplitIndex);
-        const afterNodes = this.nodes.slice(nodesSplitIndex + 1);
-        if (beforeText) {
-          beforeNodes.push(splitNode.cloneWithText(beforeText));
-        }
-        if (afterText) {
-          afterNodes.unshift(splitNode.cloneWithText(afterText));
-        }
-        this.apply(new ReplaceChildNodesAction(beforeNodes));
-        const newBlock = this.cloneWithNodes(afterNodes);
-        this.parent.apply(new InsertBlocksAfterAction(this, newBlock));
-        return newBlock;
-      }
-    }
-  }
-  /**
-   * Checks if the caret position is at the start of a specified RTETextNode.
-   *
-   * @param {RTETextNode} node - `RTETextNode` - a node representing an image in a rich text editor.
-   * @param {number} startOffset - The position within the text node where the caret is located.
-   * @returns {boolean} a boolean value, which indicates whether the caret position is at the start of the RTETextNode.
-   */
-  isCaretPositionAtStart(node, startOffset) {
-    return node === this.nodes[0] && startOffset === 0;
-  }
-  /**
-   * Checks if the caret position is at the end of a specified RTETextNode.
-   *
-   * @param {RTETextNode} node - `RTETextNode` - a node representing an image in a rich text editor.
-   * @param {number} startOffset - The position within the text node where the caret is located.
-   * @returns {boolean} a boolean value, which indicates whether the caret position is at the start of the RTETextNode.
-   */
-  isCaretPositionAtEnd(node, startOffset) {
-    const lastNode = this.nodes[this.nodes.length - 1];
-    return node === lastNode && (node.isEmpty() || startOffset === lastNode.text.length);
-  }
-  /**
-   * lineBreakSingleBlock
-   *
-   * @param {RTETextNode} splitNode -
-   * @param {number} startOffsetOfNode -
-   * @returns {Nullable<RTETextNode>} Nullable<RTETextNode>
-   */
-  lineBreakSingleBlock(splitNode, startOffsetOfNode) {
-    if (splitNode) {
-      const lineBreakNode = new RTETextNode(generateUUID(), '\n', this);
-      const beforeText = splitNode.text.slice(0, startOffsetOfNode);
-      const afterText = splitNode.text.slice(startOffsetOfNode);
-      const nodesSplitIndex = this.nodes.indexOf(splitNode);
-      if (nodesSplitIndex > -1) {
-        const beforeNodes = this.nodes.slice(0, nodesSplitIndex);
-        const afterNodes = this.nodes.slice(nodesSplitIndex + 1);
-        if (beforeText) {
-          beforeNodes.push(splitNode.cloneWithText(beforeText));
-        }
-        if (afterText) {
-          afterNodes.unshift(splitNode.cloneWithText(afterText));
-        }
-        this.mergeLineBreakNodes(beforeNodes, lineBreakNode, afterNodes);
-      }
-      return lineBreakNode;
-    }
-  }
-  /**
-   * lineBreakMultipleBlocks
-   *
-   * @param {RTEBlock[]} selectedBlocks -
-   * @returns {Nullable<RTETextNode>} Nullable<RTETextNode>
-   */
-  lineBreakMultipleBlocks(selectedBlocks) {
-    const beforeNodes = this['nodes'];
-    const lineBreakNode = new RTETextNode(generateUUID(), '\n', this);
-    const afterNodes = this.concatBlocksNodes(selectedBlocks.slice(1));
-    this.mergeLineBreakNodes(beforeNodes, lineBreakNode, afterNodes);
-    return lineBreakNode;
-  }
-  /**
-   * deleteNodeContent
-   *
-   * @param {DeleteBlockContentAction} action - ModifyContentAction
-   */
-  deleteNodeContent(action) {
-    const startContainerNode = action.startContainerNode;
-    const startOffset = action.startOffset;
-    if (startOffset !== 0 && !startContainerNode.isEmpty()) {
-      const newText = startContainerNode.text.slice(0, startOffset - 1) +
-        startContainerNode.text.slice(startOffset);
-      startContainerNode.apply(new UpdateTextAction(newText));
-      if (newText) {
-        action.previousNode = startContainerNode;
-        return;
-      }
-      else {
-        const previousNode = this.getPreviousNode(startContainerNode);
-        // Remove the last character will not delete paragraph, the paragraph will removed after press delete again
-        if ((previousNode && previousNode.parentBlock === this && previousNode['text'] === '\n') ||
-          this.nodes.length === 1) {
-          action.previousNode = startContainerNode;
-          return;
-        }
-        else {
-          this.apply(new RemoveChildAction(startContainerNode));
-          action.previousNode = previousNode;
-          return;
-        }
-      }
-    }
-    else {
-      let previousNode = this.getPreviousNode(startContainerNode);
-      let nextNode = null;
-      if (this.nodes.length && previousNode && previousNode.parentBlock !== this) {
-        if (startContainerNode.isEmpty()) {
-          this.apply(new RemoveChildAction(startContainerNode));
-        }
-        previousNode.parentBlock.apply(new MergeTwoBlocksNodesAction(this));
-      }
-      else {
-        if (this.isContentFirstNode(startContainerNode) && startContainerNode.isEmpty()) {
-          nextNode = this.getNextNode(startContainerNode);
-        }
-        /**
-         * Remove line break
-         *
-         * @example caret at the first line
-         * \n
-         * test
-         */
-        if (startContainerNode.isEmpty()) {
-          this.apply(new RemoveChildAction(startContainerNode));
-        }
-        /**
-         * Remove line break
-         *
-         * @example caret at the begin of second line
-         * \n
-         * test
-         */
-        if (previousNode instanceof RTETextNode && previousNode.isEmpty()) {
-          const shouldRemoveNode = previousNode;
-          previousNode = this.getPreviousNode(previousNode);
-          shouldRemoveNode.parentBlock.apply(new RemoveChildAction(shouldRemoveNode));
-          if (!previousNode) {
-            nextNode = startContainerNode;
-          }
-        }
-      }
-      //Remove the paragraph block if the content is empty
-      if (this.nodes.length === 0) {
-        this.parent.apply(new RemoveChildAction(this));
-      }
-      if (previousNode) {
-        action.previousNode = previousNode;
-      }
-      else if (nextNode) {
-        action.nextNode = nextNode;
-      }
-    }
-  }
-  /**
-   * Remove the child node
-   *
-   * @param {RemoveChildAction} action - Modify action
-   */
-  removeChildNode(action) {
-    this.nodes = this.nodes.filter((node) => node !== action.entityToBeRemoved);
-    if (this.nodes.length === 0) {
-      this.parent.apply(new RemoveChildAction(this));
-    }
-  }
-  /**
-   * mergeLineBreakNodes
+   * Create new empty paragraph.
    *
-   * @param {RTENode[]} beforeNodes -
-   * @param {RTETextNode} lineBreakNode -
-   * @param {RTENode[]} afterNodes -
+   * @returns {RTETextBlock} Paragraph.
    */
-  mergeLineBreakNodes(beforeNodes, lineBreakNode, afterNodes) {
-    if (afterNodes.length === 0 || (afterNodes[0] && afterNodes[0].text === '')) {
-      afterNodes.push(new RTETextNode(generateUUID(), '\n', this, beforeNodes[beforeNodes.length - 1] && beforeNodes[beforeNodes.length - 1].annotationMap));
-    }
-    this.apply(new ReplaceChildNodesAction([...beforeNodes, lineBreakNode, ...afterNodes]));
-  }
-  /**
-   * breakSingleTextBlock
-   *
-   * @param {RTETextNode} splitNode -
-   * @param {number} startOffsetOfNode -
-   * @returns {Nullable<RTEBlock>} Nullable<RTEBlock>
-   */
-  breakSingleTextBlock(splitNode, startOffsetOfNode) {
-    const newParagraph = this.copyInlineStyleToNewParagraph(splitNode);
-    if (this.isCaretPositionAtEnd(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksAfterAction(this, newParagraph));
-    }
-    else if (this.isCaretPositionAtStart(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksBeforeAction(this, newParagraph));
-    }
-    else {
-      const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
-      this.apply(splitBlockAction);
-      return splitBlockAction.newBlock;
-    }
-    return newParagraph;
+  createNewParagraph() {
+    return new RTETextBlock(generateUUID(), 'paragraph');
   }
   /**
-   * convertParagraphToList
-   *
-   * @param {TransformListAction} action - ModifyContentAction
-   */
-  convertParagraphToList(action) {
-    const bulletList = this.parent.createList(action.listType);
-    const listItems = action.selectedBlocks.map((node) => this.parent.toListItem(node));
-    bulletList.apply(new AppendChildNodesAction(listItems));
-    this.parent.apply(new InsertBlocksAfterAction(action.selectedBlocks[0], bulletList));
-    action.selectedBlocks.forEach((node) => {
-      node.parent.apply(new RemoveChildAction(node));
-    });
-  }
-  /**
-   * insertImage
-   *
-   * @param {InsertImageToBlockAction} action - ModifyContentAction
+   * @inheritDoc
    */
-  insertImage(action) {
-    const splitNode = action.splitPointNode;
-    const startOffsetOfNode = action.startOffsetOfNode;
-    const newImageBlock = action.imageBlockToBeInserted;
-    if (this.isCaretPositionAtEnd(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksAfterAction(this, newImageBlock));
-    }
-    else if (this.isCaretPositionAtStart(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksBeforeAction(this, newImageBlock));
-    }
-    else {
-      const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
-      this.apply(splitBlockAction);
-      this.parent.apply(new InsertBlocksAfterAction(this, newImageBlock));
+  doAnnotationActionApply(action) {
+    const strategy = ActionHandleStrategyRegistry.get(action.constructor.name, RTETextBlock.name);
+    if (strategy) {
+      strategy.execute(action, this);
     }
   }
-  /**
-   * copyInlineStyleToNewParagraph
-   *
-   * @param {RTETextNode} needCopedNode -
-   * @returns {RTETextBlock} RTETextBlock
-   */
-  copyInlineStyleToNewParagraph(needCopedNode) {
-    const textNode = needCopedNode.cloneWithText('');
-    // The link annotation don't need inherited
-    textNode.annotationMap.delete(NodeAnnotationTypeEnum.LINK);
-    const newParagraph = new RTETextBlock(generateUUID(), 'paragraph');
-    newParagraph.apply(new AppendChildNodesAction([textNode]));
-    return newParagraph;
-  }
 }
+(() => {
+  ActionHandleStrategyRegistry.register(TextStyleAnnotationAction.name, RTETextBlock.name, new BlockUpdateTextStyleStrategy());
+  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.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());
+})();