@globalpayments/vega 2.38.0 → 2.39.0

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-insert-line-break-with-blocks-strategy.js

@@ -0,0 +1,60 @@
+import { generateUUID } from '../../../../../utils/misc';
+import { RemoveChildAction } from '../../actions/remove-child-action';
+import { ReplaceChildNodesAction } from '../../actions/replace-child-nodes-action';
+import { RTETextNode } from '../../nodes/text-node';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert a line break node into multiple blocks selection at special position strategy.
+ */
+export class BlockInsertLineBreakWithBlocksStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    action.lineBreakNode = this.lineBreakMultipleBlocks(action.selectedBlocks, target);
+  }
+  /**
+   * lineBreakMultipleBlocks
+   *
+   * @param {RTEBlock[]} selectedBlocks -
+   * @param {RTETextBlock} target -
+   * @returns {Nullable<RTETextNode>} Nullable<RTETextNode>
+   */
+  lineBreakMultipleBlocks(selectedBlocks, target) {
+    const beforeNodes = target.nodes;
+    const lineBreakNode = new RTETextNode(generateUUID(), '\n', target);
+    const afterNodes = this.concatBlocksNodes(selectedBlocks.slice(1));
+    this.mergeLineBreakNodes(beforeNodes, lineBreakNode, afterNodes, target);
+    return lineBreakNode;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * mergeLineBreakNodes
+   *
+   * @param {RTENode[]} beforeNodes -
+   * @param {RTETextNode} lineBreakNode -
+   * @param {RTENode[]} afterNodes -
+   * @param {RTETextBlock} target -
+   */
+  mergeLineBreakNodes(beforeNodes, lineBreakNode, afterNodes, target) {
+    if (afterNodes.length === 0 || (afterNodes[0] && afterNodes[0].text === '')) {
+      afterNodes.push(new RTETextNode(generateUUID(), '\n', target, beforeNodes[beforeNodes.length - 1] && beforeNodes[beforeNodes.length - 1].annotationMap));
+    }
+    target.apply(new ReplaceChildNodesAction([...beforeNodes, lineBreakNode, ...afterNodes]));
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-insert-new-paragraph-strategy.js

@@ -0,0 +1,55 @@
+import { AppendChildNodesAction } from '../../actions/append-child-nodes-action';
+import { InsertBlocksAfterAction } from '../../actions/insert-blocks-after-block';
+import { InsertBlocksBeforeAction } from '../../actions/insert-blocks-before-block';
+import { SplitBlockWithNodeAction } from '../../actions/split-block-with-node-action';
+import { NodeAnnotationTypeEnum } from '../../annotations/node-annotation.abstract';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert new paragraph into current text block at special position.
+ */
+export class BlockInsertNewParagraphStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    action.newBlock = this.breakSingleTextBlock(action.startContainerNode, action.startOffset, target);
+  }
+  /**
+   * breakSingleTextBlock
+   *
+   * @param {RTETextNode} splitNode -
+   * @param {number} startOffsetOfNode -
+   * @param {RTETextBlock} target -
+   * @returns {Nullable<RTEBlock>} Nullable<RTEBlock>
+   */
+  breakSingleTextBlock(splitNode, startOffsetOfNode, target) {
+    const newParagraph = this.copyInlineStyleToNewParagraph(splitNode, target);
+    if (this.isCaretPositionAtTextBlockEnd(target, splitNode, startOffsetOfNode)) {
+      target.parent.apply(new InsertBlocksAfterAction(target, newParagraph));
+    }
+    else if (this.isCaretPositionAtTextBlockStart(target, splitNode, startOffsetOfNode)) {
+      target.parent.apply(new InsertBlocksBeforeAction(target, newParagraph));
+    }
+    else {
+      const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
+      target.apply(splitBlockAction);
+      return splitBlockAction.newBlock;
+    }
+    return newParagraph;
+  }
+  /**
+   * copyInlineStyleToNewParagraph
+   *
+   * @param {RTETextNode} needCopedNode - The text node.
+   * @param {RTETextBlock} target - The text block.
+   * @returns {RTETextBlock} - The new paragraph.
+   */
+  copyInlineStyleToNewParagraph(needCopedNode, target) {
+    const textNode = needCopedNode.cloneWithText('');
+    // The link annotation don't need inherited
+    textNode.annotationMap.delete(NodeAnnotationTypeEnum.LINK);
+    const newParagraph = target.createNewParagraph();
+    newParagraph.apply(new AppendChildNodesAction([textNode]));
+    return newParagraph;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-insert-nodes-after-node-strategy.js

@@ -0,0 +1,14 @@
+import { BlockReplaceNodeWithNodesStrategy } from './block-replace-node-with-nodes-strategy';
+/**
+ * Insert some text nodes at the behind of the node strategy.
+ */
+export class BlockInsertNodesAfterNodeStrategy extends BlockReplaceNodeWithNodesStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const referNode = action.referNode;
+    const nodes = [referNode, ...action.nodesToBeInserted];
+    this.replaceNodeWithNodes(target, referNode, nodes);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-insert-nodes-before-node-strategy.js

@@ -0,0 +1,14 @@
+import { BlockReplaceNodeWithNodesStrategy } from './block-replace-node-with-nodes-strategy';
+/**
+ * Insert some text nodes at the before of the node strategy.
+ */
+export class BlockInsertNodesBeforeNodeStrategy extends BlockReplaceNodeWithNodesStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const referNode = action.referNode;
+    const nodes = [...action.nodesToBeInserted, referNode];
+    this.replaceNodeWithNodes(target, referNode, nodes);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-merge-nodes-strategy.js

@@ -0,0 +1,25 @@
+import { AppendChildNodesAction } from '../../actions/append-child-nodes-action';
+import { RemoveChildAction } from '../../actions/remove-child-action';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Append the second block child nodes to the first block child nodes and remove the second block strategy.
+ */
+export class BlockMergeNodesStrategy extends ActionHandleStrategy {
+  /**
+   * Merges the child nodes of two RTEBlocks if they have the same type or both are not images.
+   *
+   * @param {MergeTwoBlocksNodesAction} action - The merge block nodes action instance.
+   * @param {RTETextBlock | RTEImageBlock} target - The first text block or image block.
+   */
+  handleAction(action, target) {
+    const anotherBlock = action.blockNeedToBeMerged;
+    if (target.type === anotherBlock.type || (target.type !== 'image' && anotherBlock.type !== 'image')) {
+      let shouldMergeNodes = anotherBlock['nodes'];
+      if (anotherBlock['type'] !== 'image') {
+        shouldMergeNodes = anotherBlock['nodes'].filter((node) => node.text);
+      }
+      target.apply(new AppendChildNodesAction(shouldMergeNodes));
+      anotherBlock.parent.apply(new RemoveChildAction(anotherBlock));
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-remove-child-block-strategy.js

@@ -0,0 +1,15 @@
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * List block or VegaRTEContent remove child block strategy.
+ */
+export class BlockRemoveChildBlockStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const blockToBeRemoved = action.entityToBeRemoved;
+    if (target.blocks) {
+      target.blocks = target.blocks.filter((block) => block !== blockToBeRemoved);
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-remove-node-strategy.js

@@ -0,0 +1,21 @@
+import { RemoveChildAction } from '../../actions/remove-child-action';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Remove the node from the text block or image block strategy.
+ */
+export class BlockRemoveNodeStrategy extends ActionHandleStrategy {
+  /**
+   * Remove the text node from the parent text block or remove the image node from the parent image block.
+   * Remove the block if the block nodes is empty after delete the current node.
+   *
+   * @param {RemoveChildAction} action - The remove child action instance.
+   * @param {RTETextBlock | RTEImageBlock} target - The parent block of the node that will be removed.
+   */
+  handleAction(action, target) {
+    const arrayFixed = target.nodes;
+    target.nodes = arrayFixed.filter((node) => node !== action.entityToBeRemoved);
+    if (target.nodes.length === 0 && target.parent) {
+      target.parent.apply(new RemoveChildAction(target));
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-replace-node-with-nodes-strategy.js

@@ -0,0 +1,28 @@
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Replace the node with new node array strategy.
+ */
+export class BlockReplaceNodeWithNodesStrategy extends ActionHandleStrategy {
+  /**
+   * Replace the current node to the new node array.
+   *
+   * @param {RTEBlock} target - The image block or the text block.
+   * @param {RTENode} referNode - The text node or the image node.
+   * @param {RTENode[]} newNodes - The array of the text node or the image node.
+   */
+  replaceNodeWithNodes(target, referNode, newNodes) {
+    if (target['nodes']) {
+      newNodes.forEach((node) => {
+        node.parentBlock = target;
+      });
+      target['nodes'] = target['nodes'].flatMap((node) => {
+        if (node === referNode) {
+          return newNodes;
+        }
+        else {
+          return node;
+        }
+      });
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-replace-nodes-strategy.js

@@ -0,0 +1,17 @@
+import { AppendChildNodesAction } from '../../actions/append-child-nodes-action';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Remove all nodes and append new nodes strategy.
+ */
+export class BlockReplaceNodesStrategy extends ActionHandleStrategy {
+  /**
+   * Empty the text block or image block nodes and add new nodes.
+   *
+   * @param {ReplaceChildNodesAction} action - The replace child nodes action instance.
+   * @param {RTETextBlock | RTEImageBlock} target - The text block or the image block.
+   */
+  handleAction(action, target) {
+    target.nodes = [];
+    target.apply(new AppendChildNodesAction(action.newChildNodes));
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-split-with-image-node-strategy.js

@@ -0,0 +1,48 @@
+import { AppendChildNodesAction } from '../../actions/append-child-nodes-action';
+import { InsertBlocksAfterAction } from '../../actions/insert-blocks-after-block';
+import { ReplaceChildNodesAction } from '../../actions/replace-child-nodes-action';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Split the current image block with a special position strategy.
+ */
+export class BlockSplitWithImageNodeStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    action.newBlock = this.splitImageNodes(action.splitPointNode, action.startOffsetOfNode, target);
+  }
+  /**
+   * 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.
+   * @param {RTEImageBlock} target The image block.
+   * @returns {Nullable<RTEBlock>} The new block after split
+   */
+  splitImageNodes(imageNode, imageOffset, target) {
+    const nodesSplitIndex = target.nodes.indexOf(imageNode);
+    if (nodesSplitIndex > -1) {
+      const beforeNodes = target.nodes.slice(0, nodesSplitIndex + imageOffset);
+      const afterNodes = target.nodes.slice(nodesSplitIndex + imageOffset);
+      target.apply(new ReplaceChildNodesAction(beforeNodes));
+      const newBlock = this.cloneWithNodes(afterNodes, target);
+      target.parent.apply(new InsertBlocksAfterAction(target, 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.
+   * @param {RTEImageBlock} target The image block.
+   * @returns {RTEImageBlock} A new `RTEImageBlock` object with the provided `nodes` appended to it.
+   */
+  cloneWithNodes(nodes, target) {
+    const block = target.createNewImageBlock();
+    block.nodes = [];
+    block.apply(new AppendChildNodesAction(nodes));
+    return block;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-split-with-text-node-strategy.js

@@ -0,0 +1,43 @@
+import { InsertBlocksAfterAction } from '../../actions/insert-blocks-after-block';
+import { ReplaceChildNodesAction } from '../../actions/replace-child-nodes-action';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Split the current node with a special position strategy.
+ */
+export class BlockSplitWithTextNodeStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    action.newBlock = this.splitTextNodeBlock(action.splitPointNode, action.startOffsetOfNode, target);
+  }
+  /**
+   * 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`.
+   * @param {RTETextBlock} textBlock - The text block need to be splited.
+   * @returns {Nullable<RTEBlock>} return either an RTEBlock object or null.
+   */
+  splitTextNodeBlock(splitNode, startOffsetOfNode, textBlock) {
+    if (splitNode) {
+      const beforeText = splitNode.text.slice(0, startOffsetOfNode);
+      const afterText = splitNode.text.slice(startOffsetOfNode);
+      const nodesSplitIndex = textBlock.nodes.indexOf(splitNode);
+      if (nodesSplitIndex > -1) {
+        const beforeNodes = textBlock.nodes.slice(0, nodesSplitIndex);
+        const afterNodes = textBlock.nodes.slice(nodesSplitIndex + 1);
+        if (beforeText) {
+          beforeNodes.push(splitNode.cloneWithText(beforeText));
+        }
+        if (afterText) {
+          afterNodes.unshift(splitNode.cloneWithText(afterText));
+        }
+        textBlock.apply(new ReplaceChildNodesAction(beforeNodes));
+        const newBlock = textBlock.cloneWithNodes(afterNodes);
+        textBlock.parent.apply(new InsertBlocksAfterAction(textBlock, newBlock));
+        return newBlock;
+      }
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-transform-to-list-strategy.js

@@ -0,0 +1,26 @@
+import { AppendChildNodesAction } from '../../actions/append-child-nodes-action';
+import { InsertBlocksAfterAction } from '../../actions/insert-blocks-after-block';
+import { RemoveChildAction } from '../../actions/remove-child-action';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Convert the selected blocks to list strategy.
+ */
+export class BlockTransformToListStrategy extends ActionHandleStrategy {
+  /**
+   * This method will create a empty list block and append all selected blocks as list item block.
+   *
+   * @param {TransformListAction} action - The transform list action instance.
+   * @param {RTETextBlock} target - The first item of the selected block.
+   */
+  handleAction(action, target) {
+    const contentState = target.parent;
+    const bulletList = contentState.createList(action.listType);
+    const selectedBlocks = action.selectedBlocks;
+    const listItems = selectedBlocks.map((block) => contentState.toListItem(block));
+    bulletList.apply(new AppendChildNodesAction(listItems));
+    contentState.apply(new InsertBlocksAfterAction(action.selectedBlocks[0], bulletList));
+    selectedBlocks.forEach((block) => {
+      block.parent.apply(new RemoveChildAction(block));
+    });
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/image-block-insert-image-strategy.js

@@ -0,0 +1,32 @@
+import { AppendChildNodesAction } from '../../actions/append-child-nodes-action';
+import { InsertBlocksAfterAction } from '../../actions/insert-blocks-after-block';
+import { InsertBlocksBeforeAction } from '../../actions/insert-blocks-before-block';
+import { SplitBlockWithNodeAction } from '../../actions/split-block-with-node-action';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert a image node at the special position of image block.
+ */
+export class ImageBlockInsertImageStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const splitNode = action.splitPointNode;
+    const startOffsetOfNode = action.startOffsetOfNode;
+    const newImageBlock = action.imageBlockToBeInserted;
+    const newImageNodes = newImageBlock.nodes;
+    if (target.nodes.length < 1) {
+      target.apply(new AppendChildNodesAction(newImageNodes));
+    }
+    else if (this.isCaretPositionAtImageBlockEnd(target, splitNode, startOffsetOfNode)) {
+      target.parent.apply(new InsertBlocksAfterAction(target, newImageBlock));
+    }
+    else if (this.isCaretPositionAtImageBlockStart(target, splitNode, startOffsetOfNode)) {
+      target.parent.apply(new InsertBlocksBeforeAction(target, newImageBlock));
+    }
+    else {
+      target.apply(new SplitBlockWithNodeAction(splitNode, startOffsetOfNode));
+      target.parent.apply(new InsertBlocksAfterAction(target, newImageBlock));
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/image-insert-line-break-strategy.js

@@ -0,0 +1,21 @@
+import { BreakSingleBlockAction } from '../../actions/break-single-block-action';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * The image block insert line break strategy.
+ */
+export class ImageInsertLineBreakStrategy extends ActionHandleStrategy {
+  /**
+   * The image block not support insert the line break node, so invoke the insert new paragraph logic directly.
+   *
+   * @param {LineBreakSingleBlockAction} action - The action instance.
+   * @param {RTEImageBlock} target - The image block.
+   */
+  handleAction(action, target) {
+    const insertNewParagraphAction = new BreakSingleBlockAction(action.startContainerNode, action.startOffset);
+    target.apply(insertNewParagraphAction);
+    const newBlock = insertNewParagraphAction.newBlock;
+    if (newBlock) {
+      action.lineBreakNode = newBlock.nodes[0];
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/image-insert-line-break-with-blocks-strategy.js

@@ -0,0 +1,55 @@
+import { generateUUID } from '../../../../../utils/misc';
+import { AppendChildNodesAction } from '../../actions/append-child-nodes-action';
+import { InsertBlocksAfterAction } from '../../actions/insert-blocks-after-block';
+import { RemoveChildAction } from '../../actions/remove-child-action';
+import { RTETextBlock } from '../../blocks/text-block';
+import { RTETextNode } from '../../nodes/text-node';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert a line break node into multiple blocks selection at special position strategy.
+ */
+export class ImageInsertLineBreakWithBlocksStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    action.lineBreakNode = this.lineBreakMultipleBlocks(action.selectedBlocks, target);
+  }
+  /**
+   * 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.
+   * @param {RTEImageBlock} target - The image block.
+   * @returns {Nullable<RTETextNode>} Returns a Nullable RTETextNode.
+   */
+  lineBreakMultipleBlocks(selectedBlocks, target) {
+    const newParagraph = RTETextBlock.from({
+      id: generateUUID(),
+      type: 'paragraph',
+      nodes: [{ id: generateUUID(), type: 'text', text: '\n' }],
+    });
+    target.parent.apply(new InsertBlocksAfterAction(target, 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];
+  }
+  /**
+   * 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;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/image-insert-new-paragraph-strategy.js

@@ -0,0 +1,44 @@
+import { generateUUID } from '../../../../../utils/misc';
+import { InsertBlocksAfterAction } from '../../actions/insert-blocks-after-block';
+import { InsertBlocksBeforeAction } from '../../actions/insert-blocks-before-block';
+import { SplitBlockWithNodeAction } from '../../actions/split-block-with-node-action';
+import { RTETextBlock } from '../../blocks/text-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert a new paragraph at the image block special position strategy.
+ */
+export class ImageInsertNewParagraphStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    action.newBlock = this.breakSingleBlock(action.startContainerNode, action.startOffset, target);
+  }
+  /**
+   * 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.
+   * @param {RTEImageBlock} target - The image block.
+   * @returns {Nullable<RTEBlock>} Returns either a new paragraph block or the new block created after splitting the original block.
+   */
+  breakSingleBlock(splitNode, startOffsetOfNode, target) {
+    const newParagraph = RTETextBlock.from({
+      id: generateUUID(),
+      type: 'paragraph',
+      nodes: [{ id: generateUUID(), type: 'text', text: '' }],
+    });
+    if (this.isCaretPositionAtImageBlockEnd(target, splitNode, startOffsetOfNode)) {
+      target.parent.apply(new InsertBlocksAfterAction(target, newParagraph));
+    }
+    else if (this.isCaretPositionAtImageBlockStart(target, splitNode, startOffsetOfNode)) {
+      target.parent.apply(new InsertBlocksBeforeAction(target, newParagraph));
+    }
+    else {
+      const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
+      target.apply(splitBlockAction);
+      return splitBlockAction.newBlock;
+    }
+    return newParagraph;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/image-update-url-strategy.js

@@ -0,0 +1,12 @@
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * The image node update property url strategy.
+ */
+export class ImageUpdateUrlStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    target.url = action.url;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/list-insert-image-strategy.js

@@ -0,0 +1,22 @@
+import { InsertBlocksAfterAction } from '../../actions/insert-blocks-after-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert image to list block strategy.
+ */
+export class ListInsertImageStrategy extends ActionHandleStrategy {
+  /**
+   * Insert image block at behind of the list item block.
+   *
+   * @param {InsertImageToBlockAction} action - The insert image action instance.
+   * @param {RTEListBlock} target - The list block.
+   */
+  handleAction(action, target) {
+    const imageBlock = action.imageBlockToBeInserted;
+    if (target.parent['type'] !== 'list-item') {
+      target.parent.apply(new InsertBlocksAfterAction(target, imageBlock));
+    }
+    else {
+      target.parent.apply(action);
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/list-item-delete-text-content-strategy.js

@@ -0,0 +1,20 @@
+import { RemoveChildAction } from '../../actions/remove-child-action';
+import { BlockDeleteTextContentStrategy } from './block-delete-text-content-strategy';
+/**
+ * The list item block block delete text content strategy.
+ */
+export class ListItemDeleteTextContentStrategy extends BlockDeleteTextContentStrategy {
+  /**
+   * Delete the list item content and delete the parent list after delete the last item.
+   *
+   * @param {DeleteBlockContentAction} action - The delete block content action instance.
+   * @param {RTEListItemBlock} target - The list item block.
+   */
+  handleAction(action, target) {
+    const listBlock = target.parent;
+    this.deleteNodeContent(action, target);
+    if (listBlock.blocks.length === 0) {
+      listBlock.parent.apply(new RemoveChildAction(listBlock));
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/list-item-insert-image-strategy.js

@@ -0,0 +1,15 @@
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert image node to list item block strategy.
+ */
+export class ListItemInsertImageStrategy extends ActionHandleStrategy {
+  /**
+   * The image node can not insert into list item block, so insert image after parent list block.
+   *
+   * @param {InsertImageToBlockAction} action - The action instance.
+   * @param {RTEListItemBlock} target - The list item block.
+   */
+  handleAction(action, target) {
+    target.parent.apply(action);
+  }
+}