@globalpayments/vega 2.38.0 → 2.39.0

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());
+})();

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

@@ -1,14 +1,14 @@
 import { RTEBlock } from './block.abstract';
 import { RTEListItemBlock } from './list-item-block';
 import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
-import { RemoveChildAction } from '../actions/remove-child-action';
-import { InsertBlocksAfterAction } from '../actions/insert-blocks-after-block';
-import { generateUUID } from '../../../../utils/misc';
-import { RTETextBlock } from './text-block';
-import { AppendChildNodesAction } from '../actions/append-child-nodes-action';
-import { InsertBlocksBeforeAction } from '../actions/insert-blocks-before-block';
-import { SyncUpSelectionAction } from '../actions/sync-up-selection-action';
-import { RemoveNestListAction } from '../actions/remove-nest-list-action';
+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';
 /**
  * List block
  */
@@ -53,151 +53,13 @@ export class RTEListBlock extends RTEBlock {
   getLastNode() {
     return this.blocks[this.blocks.length - 1].getLastNode();
   }
-  /**
-   * Apply a modify action to block
-   *
-   * @param {ModifyContentAction} action - Modify action
-   */
-  doModifyActionApply(action) {
-    switch (action.type) {
-      case ModifyContentActionType.DELETE_CHILD:
-        this.removeListItemBlock(action.entityToBeRemoved);
-        break;
-      case ModifyContentActionType.INSERT_BLOCKS_AFTER:
-        this.replaceBlockWithBlocks(action.referBlock, [
-          action.referBlock,
-          ...action.blocksToBeInserted,
-        ]);
-        break;
-      case ModifyContentActionType.INSERT_BLOCKS_BEFORE:
-        this.replaceBlockWithBlocks(action.referBlock, [
-          ...action.blocksToBeInserted,
-          action.referBlock,
-        ]);
-        break;
-      case ModifyContentActionType.APPEND_CHILD_NODES:
-        this.appendChildBlocks(action.entityToBeAppended);
-        break;
-      case ModifyContentActionType.TRANSFORM_LIST_BLOCK:
-        this.convertToList(action);
-        break;
-      case ModifyContentActionType.TRANSFORM_PARAGRAPH_BLOCK:
-        this.convertToParagraph(action);
-        break;
-      case ModifyContentActionType.INSERT_IMAGE_TO_BLOCK:
-        this.insertImage(action);
-        break;
-    }
-  }
-  /**
-   * Converts a RTEListItemBlock to a RTETextBlock representing a paragraph.
-   *
-   * @param {RTEListItemBlock} block - The block that will be covered
-   * @returns {RTETextBlock} Returns a `RTETextBlock`.
-   */
-  toParagraph(block) {
-    const textBlock = new RTETextBlock(generateUUID(), 'paragraph');
-    textBlock.apply(new AppendChildNodesAction(block['nodes']));
-    textBlock['annotationMap'] = block['annotationMap'];
-    return textBlock;
-  }
-  /**
-   * Covert block to List
-   *
-   * @param {TransformListAction} action - Modify action
-   */
-  convertToList(action) {
-    const selectedBlocks = action.selectedBlocks;
-    const bulletList = this.parent.createList(action.listType);
-    const isSameList = selectedBlocks.every((block) => block.parent === this);
-    if (isSameList) {
-      // Select one or more list items belonging to the same list, and all items in this list should be updated
-      bulletList.apply(new AppendChildNodesAction(this.blocks));
-      this.parent.apply(new InsertBlocksAfterAction(this, bulletList));
-      this.parent.apply(new RemoveChildAction(this));
-      selectedBlocks.forEach((block) => block.nodes.map((node) => node.apply(new SyncUpSelectionAction())));
-    }
-    else {
-      const listItems = action.selectedBlocks.map((block) => this.parent.toListItem(block));
-      bulletList.apply(new AppendChildNodesAction(listItems));
-      this.parent.apply(new InsertBlocksAfterAction(this, bulletList));
-      action.selectedBlocks.forEach((block) => {
-        block.parent.apply(new RemoveChildAction(block));
-      });
-      if (this.blocks.length === 0) {
-        this.parent.apply(new RemoveChildAction(this));
-      }
-    }
-  }
-  /**
-   * Covert block to paragraph
-   *
-   * @param {TransformListAction} action - Modify action
-   */
-  convertToParagraph(action) {
-    let isSelectedFirstBlock = false;
-    let isSelectedLastBlock = false;
-    const selectedBlocks = action.selectedBlocks;
-    const currentParagraph = selectedBlocks.map((block) => {
-      block.nodes.map((node) => node.apply(new SyncUpSelectionAction()));
-      if (block === this.blocks[0])
-        isSelectedFirstBlock = true;
-      if (block === this.blocks[this.blocks.length - 1])
-        isSelectedLastBlock = true;
-      return this.toParagraph(block);
-    });
-    if (isSelectedFirstBlock) {
-      this.parent.apply(new InsertBlocksBeforeAction(this, ...currentParagraph));
-    }
-    else if (isSelectedLastBlock) {
-      this.parent.apply(new InsertBlocksAfterAction(this, ...currentParagraph));
-    }
-    else {
-      const startIndex = this.blocks.indexOf(selectedBlocks[0]);
-      const lastIndex = this.blocks.indexOf(selectedBlocks[selectedBlocks.length - 1]);
-      const firstBulletList = this.parent.createList(this.type);
-      firstBulletList.apply(new AppendChildNodesAction(this.blocks.slice(0, startIndex)));
-      const lastBulletList = this.parent.createList(this.type);
-      lastBulletList.apply(new AppendChildNodesAction(this.blocks.slice(lastIndex + 1)));
-      this.parent.apply(new InsertBlocksBeforeAction(this, firstBulletList, ...currentParagraph, lastBulletList));
-      this.parent.apply(new RemoveChildAction(this));
-    }
-    selectedBlocks.map((block) => {
-      this.apply(new RemoveChildAction(block));
-    });
-    if (this.blocks.length === 0) {
-      this.parent.apply(new RemoveChildAction(this));
-    }
-  }
-  /**
-   * Inserts an image block into a rich text editor block based on the parent block type.
-   *
-   * @param {InsertImageToBlockAction} action - Modify action
-   */
-  insertImage(action) {
-    const imageBlock = action.imageBlockToBeInserted;
-    if (this.parent['type'] !== 'list-item') {
-      this.parent.apply(new InsertBlocksAfterAction(this, imageBlock));
-    }
-    else {
-      this.parent.apply(action);
-    }
-  }
-  /**
-   * Removes a specified block and handles the removal of nested lists if necessary.
-   *
-   * @param {RTEBlock} blockToBeRemoved - block that will be removed
-   */
-  removeListItemBlock(blockToBeRemoved) {
-    super.removeChildBlock(blockToBeRemoved);
-    if (this.blocks.length === 0 && this.parent) {
-      // The parent is a list item mean the current block is a nest list, so we need to use RemoveNestListAction to remove the item
-      if (this.parent instanceof RTEListItemBlock) {
-        this.parent.apply(new RemoveNestListAction(this));
-      }
-      else {
-        this.parent.apply(new RemoveChildAction(this));
-      }
-    }
-  }
 }
+(() => {
+  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());
+})();