@globalpayments/vega 2.38.0 → 2.40.0

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

@@ -6,16 +6,12 @@ import { VegaInternalRichTextEditorFlushChanges } from '../../../../helpers/even
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 import { HorizontalAlignmentAnnotation } from '../annotations/horizontal-alignment-annotation';
 import { IndentAnnotation } from '../annotations/indent-annotation';
-import { BlockBaseOperator } from '../helper/block-base-operator';
-import { AppendChildNodesAction } from '../actions/append-child-nodes-action';
-import { RemoveChildAction } from '../actions/remove-child-action';
-import { ZERO_WIDTH_SPACE } from '../../constants/constant';
+import { ActionHandleStrategyRegistry } from '../action-handle-strategies/action-handle-strategy-registry';
 /**
  * Abstract class for block
  */
-export class RTEBlock extends BlockBaseOperator {
+export class RTEBlock {
   constructor(id) {
-    super();
     this.annotationMap = new Map();
     this.id = id;
   }
@@ -85,7 +81,7 @@ export class RTEBlock extends BlockBaseOperator {
    */
   doApply(action) {
     if (action instanceof ModifyContentAction) {
-      this.doModifyActionApply(action);
+      ActionHandleStrategyRegistry.executeTheStrategy(action, this);
     }
     else {
       this.applyAnnotationAction(action);
@@ -101,212 +97,4 @@ export class RTEBlock extends BlockBaseOperator {
     this.annotationMap.set(annotation.type, annotation);
     typeof this.doAnnotationActionApply === 'function' && this.doAnnotationActionApply(action);
   }
-  /**
-   * Appends a list of RTENode objects to the current node's child nodes and sets the parent block of each node to the current node.
-   *
-   * @param {RTENode[]} nodesToBeAppended - An array of `RTENode` objects that you want to append to the current block.
-   */
-  appendChildNodes(nodesToBeAppended) {
-    nodesToBeAppended.forEach((node) => {
-      node.parentBlock = this;
-    });
-    this['nodes'] = this['nodes'].concat(nodesToBeAppended);
-  }
-  /**
-   * Merges the child nodes of two RTEBlocks if they have the same type or both are not images.
-   *
-   * @param {RTEBlock} secondBlock - A block of content in a rich text editor, such as a paragraph, heading, image, etc.
-   */
-  mergeTwoBlocksNodes(secondBlock) {
-    if (this.type === secondBlock.type || (this.type !== 'image' && secondBlock.type !== 'image')) {
-      let shouldMergeNodes = secondBlock['nodes'];
-      if (this.type !== 'image') {
-        shouldMergeNodes = secondBlock['nodes'].filter((node) => node['text'] && node['text'] !== ZERO_WIDTH_SPACE);
-      }
-      this.apply(new AppendChildNodesAction(shouldMergeNodes));
-      secondBlock.parent.apply(new RemoveChildAction(secondBlock));
-    }
-  }
-  /**
-   * Concat the child nodes of multiple RTEBlocks if both are not images.
-   *
-   * @param {RTEBlock[]} blocks - multiple block of content in a rich text editor, such as a paragraph, heading, image, etc.
-   * @returns {RTENode[]} Array of connected block nodes
-   */
-  concatBlocksNodes(blocks) {
-    const nodes = [];
-    blocks.map((block) => {
-      if (block.type !== 'image') {
-        nodes.push(...block['nodes']);
-        block.parent.apply(new RemoveChildAction(block));
-      }
-    });
-    return nodes;
-  }
-  /**
-   * Returns the previous node relative to the current node in a rich text editor structure.
-   *
-   * @param {RTENode} currentNode - An object of type `RTENode`.
-   * @returns {Nullable<RTENode>} the previous block last node
-   */
-  getPreviousNode(currentNode) {
-    const currentBlock = currentNode.parentBlock;
-    const currentIndex = currentBlock['nodes'].indexOf(currentNode);
-    if (currentIndex > 0) {
-      return currentBlock['nodes'][currentIndex - 1];
-    }
-    else if (currentBlock.parent) {
-      const previousBlock = this.getPreviousBlock(currentBlock);
-      if (previousBlock) {
-        return this.getBlockLastNode(previousBlock);
-      }
-    }
-  }
-  /**
-   * Returns the next node relative to the current node in a rich text editor structure.
-   *
-   * @param {RTENode} currentNode - An object of type `RTENode`.
-   * @returns {Nullable<RTENode>} the next block first node
-   */
-  getNextNode(currentNode) {
-    const currentBlock = currentNode.parentBlock;
-    const currentIndex = currentBlock['nodes'].indexOf(currentNode);
-    if (currentBlock['nodes'][currentIndex + 1]) {
-      return currentBlock['nodes'][currentIndex + 1];
-    }
-    else if (currentBlock.parent) {
-      const nextBlock = this.getNextBlock(currentBlock);
-      if (nextBlock) {
-        return this.getBlockFirstNode(nextBlock);
-      }
-    }
-  }
-  /**
-   * Determines if a given node is the first node within the current state.
-   *
-   * @param {RTENode} currentNode - An object representing a node in a rich text editor (RTE).
-   * @returns {boolean} True or false;
-   */
-  isContentFirstNode(currentNode) {
-    const currentBlock = currentNode.parentBlock;
-    const currentIndex = currentBlock['nodes'].indexOf(currentNode);
-    const parent = currentBlock.parent;
-    if (currentBlock.type === 'list-item') {
-      const listParent = parent.parent;
-      return (currentIndex === 0 &&
-        Array.isArray(parent.blocks) &&
-        parent.blocks[0] === currentBlock &&
-        listParent['type'] !== 'list-item' &&
-        Array.isArray(listParent.blocks) &&
-        listParent.blocks[0] === parent);
-    }
-    else {
-      return currentIndex === 0 && Array.isArray(parent.blocks) && parent.blocks[0] === currentBlock;
-    }
-  }
-  /**
-   * Returns the last node within a given RTE block, handling different block types accordingly.
-   *
-   * @param {RTEBlock} currentBlock - Returns the last node within that block.
-   * @returns {Nullable<RTENode>} Returns the last node of the given `currentBlock` object.
-   */
-  getBlockLastNode(currentBlock) {
-    if (currentBlock.type === 'list-item') {
-      if (currentBlock['children'] && currentBlock['children'].length > 0) {
-        return this.getBlockLastNode(currentBlock['children'][currentBlock['children'].length - 1]);
-      }
-      else {
-        return currentBlock['nodes'][currentBlock['nodes'].length - 1];
-      }
-    }
-    else if (currentBlock.type === 'number-list' || currentBlock.type === 'bullet-list') {
-      if (currentBlock.blocks) {
-        const lastListItem = currentBlock.blocks[currentBlock.blocks.length - 1];
-        return this.getBlockLastNode(lastListItem);
-      }
-    }
-    else {
-      if (currentBlock['nodes']) {
-        return currentBlock['nodes'][currentBlock['nodes'].length - 1];
-      }
-    }
-  }
-  /**
-   * Returns the first node within a given RTE block, handling different block types accordingly.
-   *
-   * @param {RTEBlock} currentBlock - Returns the first node within that block.
-   * @returns {Nullable<RTENode>} Returns the first node of the given `currentBlock` object.
-   */
-  getBlockFirstNode(currentBlock) {
-    if (currentBlock.type === 'number-list' || currentBlock.type === 'bullet-list') {
-      if (currentBlock.blocks) {
-        const firstListItem = currentBlock.blocks[0];
-        return this.getBlockFirstNode(firstListItem);
-      }
-    }
-    else {
-      if (currentBlock['nodes']) {
-        return currentBlock['nodes'][0];
-      }
-    }
-  }
-  /**
-   * TODO: The getPreviousBlock add nest list support
-   * This function retrieves the previous block in a rich text editor, considering different scenarios such as being in a bullet list.
-   *
-   * @param {RTEBlock} currentBlock - Used to retrieve the previous block relative to the given `currentBlock` within a rich text editor context.
-   * @returns {Nullable<RTEBlock>} The previous block if existing
-   */
-  getPreviousBlock(currentBlock) {
-    if (currentBlock && currentBlock.parent && currentBlock.parent.blocks) {
-      const currentBlockIndex = currentBlock.parent.blocks.indexOf(currentBlock);
-      if (currentBlockIndex > 0) {
-        return currentBlock.parent.blocks[currentBlockIndex - 1];
-      }
-      else if ((currentBlock.parent['type'] === 'number-list' ||
-        currentBlock.parent['type'] === 'bullet-list') &&
-        currentBlockIndex === 0) {
-        return this.getPreviousBlock(currentBlock.parent);
-      }
-    }
-  }
-  /**
-   * This function retrieves the next block in a rich text editor, considering different scenarios such as being in a bullet list.
-   *
-   * @param {RTEBlock} currentBlock - Used to retrieve the next block relative to the given `currentBlock` within a rich text editor context.
-   * @returns {Nullable<RTEBlock>} The next block if existing
-   */
-  getNextBlock(currentBlock) {
-    if (currentBlock && currentBlock.parent && currentBlock.parent.blocks) {
-      const currentBlockIndex = currentBlock.parent.blocks.indexOf(currentBlock);
-      if (currentBlock.parent.blocks[currentBlockIndex + 1]) {
-        return currentBlock.parent.blocks[currentBlockIndex + 1];
-      }
-      else if (currentBlock.type === 'list-item' &&
-        currentBlock.parent.blocks.length === currentBlockIndex + 1) {
-        return this.getNextBlock(currentBlock.parent);
-      }
-    }
-  }
-  /**
-   * Replaces a specific node with an array of nodes within a RTENode array.
-   *
-   * @param {RTENode} referNode - Used as a reference node to identify the node that needs to be replaced in the `nodes` array.
-   * @param {RTENode[]} nodes - An array of RTENode objects that you want to replace the `referNode` with in the `nodes` array.
-   */
-  replaceNodeWithNodes(referNode, nodes) {
-    if (this['nodes']) {
-      nodes.forEach((node) => {
-        node.parentBlock = this;
-      });
-      this['nodes'] = this['nodes'].flatMap((node) => {
-        if (node === referNode) {
-          return nodes;
-        }
-        else {
-          return node;
-        }
-      });
-    }
-  }
 }

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

@@ -1,16 +1,21 @@
 import { RTEBlock } from './block.abstract';
 import { RTEImageNode } from '../nodes/image-node';
 import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
-import { RemoveChildAction } from '../actions/remove-child-action';
 import { isNonNullable } from '../../../../types/type-guard';
-import { AppendChildNodesAction } from '../actions/append-child-nodes-action';
-import { ReplaceChildNodesAction } from '../actions/replace-child-nodes-action';
 import { generateUUID } from '../../../../utils/misc';
-import { InsertBlocksAfterAction } from '../actions/insert-blocks-after-block';
-import { SplitBlockWithNodeAction } from '../actions/split-block-with-node-action';
-import { RTETextBlock } from './text-block';
-import { InsertBlocksBeforeAction } from '../actions/insert-blocks-before-block';
-import { RTETextNode } from '../nodes/text-node';
+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';
 /**
  * Image block
  */
@@ -59,243 +64,25 @@ export class RTEImageBlock extends RTEBlock {
     return this.nodes[this.nodes.length - 1];
   }
   /**
-   * Apply a modify action to block
+   * Create a new image block.
    *
-   * @param {ModifyContentAction} action - Modify action
+   * @returns {RTEImageBlock} - The empty image block.
    */
-  doModifyActionApply(action) {
-    switch (action.type) {
-      case ModifyContentActionType.DELETE_CHILD:
-        this.removeChildNode(action);
-        break;
-      case ModifyContentActionType.CLEAR_CHILD_NODES:
-        this.nodes = [];
-        break;
-      case ModifyContentActionType.APPEND_CHILD_NODES:
-        this.appendChildNodes(action.entityToBeAppended);
-        break;
-      case ModifyContentActionType.REPLACE_CHILD_NODES:
-        this.nodes = [];
-        this.appendChildNodes(action.newChildNodes);
-        break;
-      case ModifyContentActionType.SPLIT_BLOCK_WITH_NODE:
-        action.newBlock = this.splitImageNodes(action.splitPointNode, action.startOffsetOfNode);
-        break;
-      case ModifyContentActionType.MERGE_TWO_BLOCKS_NODES:
-        this.mergeTwoBlocksNodes(action.blockNeedToBeMerged);
-        break;
-      case ModifyContentActionType.BREAK_SINGLE_BLOCK:
-        action.newBlock = this.breakSingleBlock(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.deleteNodeContent(action);
-        break;
-      case ModifyContentActionType.INSERT_IMAGE_TO_BLOCK:
-        this.insertImage(action);
-        break;
-      case ModifyContentActionType.INSERT_NODES_AFTER:
-        this.replaceNodeWithNodes(action.referNode, [
-          action.referNode,
-          ...action.nodesToBeInserted,
-        ]);
-        break;
-      case ModifyContentActionType.INSERT_NODES_BEFORE:
-        this.replaceNodeWithNodes(action.referNode, [
-          ...action.nodesToBeInserted,
-          action.referNode,
-        ]);
-        break;
-    }
-  }
-  /**
-   * Removes a specified child node from a list of nodes and triggers a parent action if the list becomes empty.
-   *
-   * @param {RemoveChildAction} action - Action to be performed when removing a child node from the list of nodes.
-   */
-  removeChildNode(action) {
-    this.nodes = this.nodes.filter((node) => node !== action.entityToBeRemoved);
-    if (this.nodes.length === 0) {
-      this.parent.apply(new RemoveChildAction(this));
-    }
-  }
-  /**
-   * The image offset should be 0 or 1
-   * <vega-rich-text-image-editor><img /></vega-rich-text-image-editor>
-   *
-   * @param {RTEImageNode} imageNode The split point image node
-   * @param {number} imageOffset The cursor point 0 | 1
-   * @returns {Nullable<RTEBlock>} The new block after split
-   */
-  splitImageNodes(imageNode, imageOffset) {
-    const nodesSplitIndex = this.nodes.indexOf(imageNode);
-    if (nodesSplitIndex > -1) {
-      const beforeNodes = this.nodes.slice(0, nodesSplitIndex + imageOffset);
-      const afterNodes = this.nodes.slice(nodesSplitIndex + imageOffset);
-      this.apply(new ReplaceChildNodesAction(beforeNodes));
-      const newBlock = this.cloneWithNodes(afterNodes);
-      this.parent.apply(new InsertBlocksAfterAction(this, newBlock));
-      return newBlock;
-    }
-  }
-  /**
-   * Creates a new RTEImageBlock instance with the provided RTEImageNode instances appended to it.
-   *
-   * @param {RTEImageNode[]} nodes - An array of RTEImageNode objects that will be used to create a new RTEImageBlock instance.
-   * @returns {RTEImageBlock} A new `RTEImageBlock` object with the provided `nodes` appended to it.
-   */
-  cloneWithNodes(nodes) {
-    const block = new RTEImageBlock(generateUUID());
-    block.nodes = [];
-    block.apply(new AppendChildNodesAction(nodes));
-    return block;
-  }
-  /**
-   * Used to split a block of text at a specific position and insert a new paragraph block.
-   *
-   * @param {RTEImageNode} splitNode - The node that needs to be split into separate blocks.
-   * @param {number} startOffsetOfNode - The index or position within the `splitNode` where the block should be broken or split.
-   * @returns {Nullable<RTEBlock>} Returns either a new paragraph block or the new block created after splitting the original block.
-   */
-  breakSingleBlock(splitNode, startOffsetOfNode) {
-    const newParagraph = RTETextBlock.from({
-      id: generateUUID(),
-      type: 'paragraph',
-      nodes: [{ id: generateUUID(), type: 'text', text: '' }],
-    });
-    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;
-  }
-  /**
-   * Breaks a single block of text at a specified offset and returns the first node of the new paragraph if created.
-   *
-   * @param {RTEImageNode} splitNode - It represents a node in a rich text editor that contains an image.
-   * @param {number} startOffset - The index at which the line break should occur within the `RTEImageNode` block.
-   * @returns {Nullable<RTETextNode>} Returning the first node of the `newParagraph` block if `newParagraph` is not null.
-   */
-  lineBreakSingleBlock(splitNode, startOffset) {
-    const newParagraph = this.breakSingleBlock(splitNode, startOffset);
-    if (newParagraph) {
-      return newParagraph['nodes'][0];
-    }
-  }
-  /**
-   * Checks if the caret position is at the start of a specified RTEImageNode.
-   *
-   * @param {RTEImageNode} node - `RTEImageNode` - 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 RTEImageNode.
-   */
-  isCaretPositionAtStart(node, startOffset) {
-    return node === this.nodes[0] && startOffset === 0;
-  }
-  /**
-   * Checks if the caret position is at the end of a given RTEImageNode.
-   *
-   * @param {RTEImageNode} node - `node` is a RTEImageNode
-   * @param {number} startOffset - The position within the `RTEImageNode` where the caret is located.
-   * @returns {boolean}Returns a boolean value indicating whether the caret position is at the end of the `RTEImageNode`.
-   */
-  isCaretPositionAtEnd(node, startOffset) {
-    const lastNode = this.nodes[this.nodes.length - 1];
-    return node === lastNode && startOffset === 1;
-  }
-  /**
-   * Inserts a new paragraph block with a line break after a selected block of text in a rich text editor.
-   *
-   * @param {RTEBlock[]} selectedBlocks - An array of RTEBlock objects that represent the blocks that have been selected for a specific action in the Rich Text Editor.
-   * @returns {Nullable<RTETextNode>} Returns a Nullable RTETextNode.
-   */
-  lineBreakMultipleBlocks(selectedBlocks) {
-    const newParagraph = RTETextBlock.from({
-      id: generateUUID(),
-      type: 'paragraph',
-      nodes: [{ id: generateUUID(), type: 'text', text: '\n' }],
-    });
-    this.parent.apply(new InsertBlocksAfterAction(this, newParagraph));
-    const afterNodes = this.concatBlocksNodes(selectedBlocks.slice(1));
-    if (afterNodes.length === 0 || (afterNodes[0] && afterNodes[0].text === '')) {
-      afterNodes.push(new RTETextNode(generateUUID(), '\n', newParagraph));
-    }
-    newParagraph.apply(new AppendChildNodesAction(afterNodes));
-    return newParagraph['nodes'][0];
-  }
-  /**
-   * Deletes content from a block node based on specific conditions.
-   *
-   * @param {DeleteBlockContentAction} action - Delete block content action
-   */
-  deleteNodeContent(action) {
-    const startContainerNode = action
-      .startContainerNode, startOffset = action.startOffset;
-    let previousNode = this.getPreviousNode(startContainerNode);
-    let nextNode = null;
-    if (startOffset === 1) {
-      const parentBlock = startContainerNode.parentBlock;
-      if (this.isContentFirstNode(startContainerNode)) {
-        nextNode = this.getNextNode(startContainerNode);
-      }
-      if (parentBlock.nodes.length === 1) {
-        parentBlock.parent.apply(new RemoveChildAction(parentBlock));
-      }
-      else {
-        startContainerNode.parentBlock.apply(new RemoveChildAction(startContainerNode));
-      }
-    }
-    else {
-      const shouldRemoveNode = previousNode;
-      if (shouldRemoveNode && shouldRemoveNode instanceof RTEImageNode) {
-        previousNode = this.getPreviousNode(shouldRemoveNode);
-        shouldRemoveNode.parentBlock.apply(new RemoveChildAction(shouldRemoveNode));
-        if (!previousNode) {
-          action.nextNode = startContainerNode;
-        }
-      }
-    }
-    if (previousNode) {
-      action.previousNode = previousNode;
-    }
-    else if (nextNode) {
-      action.nextNode = nextNode;
-    }
-  }
-  /**
-   * Image will always create new image block
-   *
-   * @param {InsertImageToBlockAction} action insert image to current block
-   */
-  insertImage(action) {
-    const splitNode = action.splitPointNode;
-    const startOffsetOfNode = action.startOffsetOfNode;
-    const newImageNodes = action.imageBlockToBeInserted.nodes;
-    const newImageBlock = action.imageBlockToBeInserted;
-    if (this.nodes.length < 1) {
-      this.apply(new AppendChildNodesAction(newImageNodes));
-    }
-    else 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 {
-      this.apply(new SplitBlockWithNodeAction(splitNode, startOffsetOfNode));
-      this.parent.apply(new InsertBlocksAfterAction(this, newImageBlock));
-    }
+  createNewImageBlock() {
+    return new RTEImageBlock(generateUUID());
   }
 }
+(() => {
+  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());
+})();