@globalpayments/vega 2.37.2 → 2.39.0

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/apply-annotation-strategies/node-split-text-strategy.js

@@ -0,0 +1,134 @@
+import { InternalAnnotationTypeEnum } from '../../annotations/annotation.abstract';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+import { TextSplittableAction } from '../../actions/splittable-action.abstract';
+import stateEntityRenderingRegistry from '../../../slimmers/controllers/state-entity-rendering-registry';
+/**
+ * Split the text node into two or there nodes according to the rules.
+ */
+export class NodeSplitTextStrategy extends ActionHandleStrategy {
+  constructor() {
+    super(...arguments);
+    // The new create node that need apply annotation or the current target. This property used to export after the execute method invoke.
+    this.applyTargetNode = null;
+  }
+  /**
+   * Split the text node.
+   *
+   * @param {TextSplittableAction} action - The split action.
+   * @param {RTETextNode} target - The text node that need to be splited.
+   * @returns {Nullable<RTETextNode>} - The new insert text node or the current text node that need to apply the action.
+   */
+  handleAction(action, target) {
+    const selectionRangeAnnotation = target.getAnnotationByType(InternalAnnotationTypeEnum.SELECTION_RANGE);
+    this.setApplyTargetNode(null);
+    if (action instanceof TextSplittableAction && action.doSplit && selectionRangeAnnotation) {
+      const { startContainer, endContainer, startOffset, endOffset } = selectionRangeAnnotation.range;
+      const noTextRangeSelected = startContainer === endContainer && startOffset === endOffset;
+      target.parentBlock.nodes = target.parentBlock.nodes.flatMap((item) => {
+        if (item.id === target.id) {
+          if (noTextRangeSelected) {
+            return this.insertNewNode(startOffset, target);
+          }
+          if (this.shouldSplitSelection(selectionRangeAnnotation.range)) {
+            return this.splitTextNode(selectionRangeAnnotation.range, target);
+          }
+          else {
+            this.setApplyTargetNode(target);
+            return target;
+          }
+        }
+        return item;
+      });
+    }
+    return this.applyTargetNode;
+  }
+  /**
+   * Insert the new node at the start offset
+   *
+   * @param {number} startOffset - The start position offset
+   * @param {RTETextNode} target - RTETextNode
+   * @returns {RTETextNode[]} - RTETextNode array
+   */
+  insertNewNode(startOffset, target) {
+    const newNode = target.cloneWithText('');
+    this.setApplyTargetNode(newNode);
+    if (startOffset === 0) {
+      return [newNode, target];
+    }
+    if (startOffset === target.text.length) {
+      return [target, newNode];
+    }
+    const beforeNode = target.cloneWithText(target.text.substring(0, startOffset));
+    const afterNode = target.cloneWithText(target.text.substring(startOffset));
+    return [beforeNode, newNode, afterNode];
+  }
+  /**
+   * Whether a given range should be split based on various conditions within the range.
+   *
+   * @param {Range} range - Selection range
+   * @returns {boolean} Returns a boolean value indicating whether the selection range should be split.
+   */
+  shouldSplitSelection(range) {
+    const { startContainer, endContainer, startOffset, endOffset } = range;
+    const isCrossNode = startContainer !== endContainer;
+    const isPartialStart = startOffset > 0;
+    const isPartialEnd = endOffset < (endContainer.textContent ? endContainer.textContent.length : 0);
+    const isPartialSelection = isPartialStart || isPartialEnd;
+    return isCrossNode || isPartialSelection;
+  }
+  /**
+   * Split text node with range
+   *
+   * @param {Range} range - Selection range
+   * @param {RTETextNode} target - RTETextNode
+   * @returns {RTETextNode[] | this} RTETextNode array
+   */
+  splitTextNode(range, target) {
+    const { startContainer, endContainer, startOffset } = range;
+    const startNode = startContainer.parentElement;
+    const endNode = endContainer.parentElement;
+    /**
+     * Split the text from the start offset to the end offset
+     *
+     * @param {string} text - The text string
+     * @param {number} startOffset - The start offset position
+     * @param {number} endOffset - The end offset position
+     * @returns {RTETextNode[]} - The split text node array
+     */
+    const splitText = (text, startOffset, endOffset) => {
+      const beforeText = text.substring(0, startOffset);
+      const selectedText = text.substring(startOffset, endOffset);
+      const afterText = text.substring(endOffset);
+      return [
+        target.cloneWithText(beforeText),
+        target.cloneWithText(selectedText),
+        target.cloneWithText(afterText),
+      ];
+    };
+    const startItemDto = startNode && stateEntityRenderingRegistry.getEntityByDOM(startNode);
+    const endItemDto = endNode && stateEntityRenderingRegistry.getEntityByDOM(endNode);
+    if (startItemDto && startItemDto.id === target.id) {
+      const endOffset = startContainer === endContainer ? range.endOffset : target.text.length;
+      const [beforeNode, selectedNode, afterNode] = splitText(target.text, startOffset, endOffset);
+      this.setApplyTargetNode(selectedNode);
+      return [beforeNode, selectedNode, afterNode].filter((node) => !!node.text);
+    }
+    else if (endItemDto && endItemDto.id === target.id) {
+      const [beforeNode, selectedNode, afterNode] = splitText(target.text, 0, range.endOffset);
+      this.setApplyTargetNode(selectedNode);
+      return [beforeNode, selectedNode, afterNode].filter((node) => !!node.text);
+    }
+    else {
+      this.setApplyTargetNode(target);
+      return target;
+    }
+  }
+  /**
+   * Store the text node which need to apply the annotation. Clear the value if the input is null.
+   *
+   * @param {RTETextNode | null} node - The new text node.
+   */
+  setApplyTargetNode(node) {
+    this.applyTargetNode = node;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/apply-annotation-strategies/node-update-annotation-map-strategy.js

@@ -0,0 +1,47 @@
+import { isNonNullable } from '../../../../../types/type-guard';
+import { ClearFormattingAnnotationAction } from '../../actions/clear-formatting-annotation-action';
+import { CodeAnnotationAction } from '../../actions/code-annotation-action';
+import { DeleteNodeAnnotationAction } from '../../actions/delete-node-annotation-action';
+import { LinkAnnotationAction } from '../../actions/link-annotation-action';
+import { LinkGroupAnnotationAction } from '../../actions/link-group-annotation-action';
+import { ClearFormattingAnnotation } from '../../annotations/clear-formatting-annotation';
+import { NodeAnnotation } from '../../annotations/node-annotation.abstract';
+import { SelectionRangeAnnotation } from '../../annotations/selection-range-annotation';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * The current strategy used to modify the text node annotation map.
+ */
+export class NodeUpdateAnnotationMapStrategy extends ActionHandleStrategy {
+  /**
+   * Remove or set annotation to the text node annotation map.
+   *
+   * @param {AnnotationAction} action - The annotation action instance.
+   * @param {RTETextNode} target - The current text node.
+   */
+  handleAction(action, target) {
+    const annotation = action.toAnnotation();
+    if (action instanceof DeleteNodeAnnotationAction) {
+      target.annotationMap.delete(action.annotationType);
+      return;
+    }
+    if (annotation instanceof ClearFormattingAnnotation) {
+      annotation.items.forEach((item) => {
+        target.deleteAnnotationByType(item);
+      });
+      return;
+    }
+    if (annotation instanceof NodeAnnotation || annotation instanceof SelectionRangeAnnotation) {
+      if (action instanceof LinkAnnotationAction) {
+        if (isNonNullable(action.newText)) {
+          target.text = action.newText;
+        }
+        target.parentBlock.apply(new LinkGroupAnnotationAction(action.link.groupKey, [target]));
+      }
+      if (action instanceof CodeAnnotationAction) {
+        this.handleAction(new ClearFormattingAnnotationAction(), target);
+      }
+      target.annotationMap.set(annotation.type, annotation);
+      return;
+    }
+  }
+}

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

@@ -0,0 +1,19 @@
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Append new block array to list block or VegaRTEContent instance strategy.
+ */
+export class BlockAppendBlocksStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const newBlocks = action.entityToBeAppended;
+    if (target.blocks) {
+      newBlocks.forEach((block) => {
+        block.parent = target;
+      });
+      const arrayFixed = target.blocks;
+      target.blocks = arrayFixed.concat(newBlocks);
+    }
+  }
+}

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

@@ -0,0 +1,21 @@
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Append the nodes to the text block or image block strategy.
+ */
+export class BlockAppendNodesStrategy extends ActionHandleStrategy {
+  /**
+   * Append the text nodes to the text block or the image block.
+   *
+   * @param {AppendChildNodesAction} action - The remove child action instance.
+   * @param {RTETextBlock | RTEImageBlock} target - The parent block of the node that will be removed.
+   */
+  handleAction(action, target) {
+    const nodesToBeAppended = action.entityToBeAppended;
+    nodesToBeAppended.forEach((node) => {
+      node.parentBlock = target;
+    });
+    // This line is used to fix the typescript error `This expression is not callable`. https://github.com/microsoft/TypeScript/issues/44373
+    const arrayFixed = target.nodes;
+    target.nodes = arrayFixed.concat(nodesToBeAppended);
+  }
+}

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

@@ -0,0 +1,54 @@
+import { RemoveChildAction } from '../../actions/remove-child-action';
+import { RTEImageNode } from '../../nodes/image-node';
+import { BlockDeleteNodeContentStrategy } from './block-delete-node-content-strategy';
+/**
+ * The image block delete the image node strategy.
+ */
+export class BlockDeleteImageStrategy extends BlockDeleteNodeContentStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    this.deleteNodeContent(action, target);
+  }
+  /**
+   * Deletes content from a block node based on specific conditions.
+   *
+   * @param {DeleteBlockContentAction} action - Delete block content action
+   * @param {RTEImageBlock} target - The image block.
+   */
+  deleteNodeContent(action, target) {
+    const startContainerNode = action
+      .startContainerNode, startOffset = action.startOffset;
+    let previousNode = this.getPreviousNode(startContainerNode);
+    let nextNode = null;
+    if (startOffset === 1) {
+      const parentBlock = target;
+      if (this.isContentFirstNode(startContainerNode)) {
+        nextNode = this.getNextNode(startContainerNode);
+      }
+      if (parentBlock.nodes.length === 1) {
+        parentBlock.parent.apply(new RemoveChildAction(parentBlock));
+      }
+      else {
+        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;
+    }
+  }
+}

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

@@ -0,0 +1,152 @@
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * The delete node content contains some common functions that used for image block delete the image node or text block delete text node.
+ */
+export class BlockDeleteNodeContentStrategy extends ActionHandleStrategy {
+  /**
+   * 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);
+    }
+  }
+  /**
+   * 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);
+      }
+    }
+  }
+  /**
+   * 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') {
+      const listItems = currentBlock.blocks;
+      if (listItems) {
+        const lastListItem = listItems[listItems.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];
+      }
+    }
+  }
+  /**
+   * 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);
+      }
+    }
+  }
+}

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

@@ -0,0 +1,99 @@
+import { MergeTwoBlocksNodesAction } from '../../actions/merge-two-blocks-nodes-action';
+import { RemoveChildAction } from '../../actions/remove-child-action';
+import { UpdateTextAction } from '../../actions/update-text-action';
+import { RTETextNode } from '../../nodes/text-node';
+import { BlockDeleteNodeContentStrategy } from './block-delete-node-content-strategy';
+/**
+ * The text block delete text content strategy.
+ */
+export class BlockDeleteTextContentStrategy extends BlockDeleteNodeContentStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    this.deleteNodeContent(action, target);
+  }
+  /**
+   * Handle the delete text logic when press delete key.
+   *
+   * @param {DeleteBlockContentAction} action - ModifyContentAction
+   * @param {RTETextBlock} target - Current text block
+   */
+  deleteNodeContent(action, target) {
+    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 === target && previousNode['text'] === '\n') ||
+          target.nodes.length === 1) {
+          action.previousNode = startContainerNode;
+          return;
+        }
+        else {
+          target.apply(new RemoveChildAction(startContainerNode));
+          action.previousNode = previousNode;
+          return;
+        }
+      }
+    }
+    else {
+      let previousNode = this.getPreviousNode(startContainerNode);
+      let nextNode = null;
+      if (target.nodes.length && previousNode && previousNode.parentBlock !== target) {
+        if (startContainerNode.isEmpty()) {
+          target.apply(new RemoveChildAction(startContainerNode));
+        }
+        previousNode.parentBlock.apply(new MergeTwoBlocksNodesAction(target));
+      }
+      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()) {
+          target.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 (target.nodes.length === 0) {
+        target.parent.apply(new RemoveChildAction(target));
+      }
+      if (previousNode) {
+        action.previousNode = previousNode;
+      }
+      else if (nextNode) {
+        action.nextNode = nextNode;
+      }
+    }
+  }
+}

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

@@ -0,0 +1,15 @@
+import { BlockInsertBlocksBeforeStrategy } from './block-insert-blocks-before-strategy';
+/**
+ * Insert block array at the behind of the block strategy.
+ */
+export class BlockInsertBlocksAfterStrategy extends BlockInsertBlocksBeforeStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    this.replaceBlockWithBlocks(target, action.referBlock, [
+      action.referBlock,
+      ...action.blocksToBeInserted,
+    ]);
+  }
+}

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

@@ -0,0 +1,38 @@
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert block array at the front of the block strategy.
+ */
+export class BlockInsertBlocksBeforeStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    this.replaceBlockWithBlocks(target, action.referBlock, [
+      ...action.blocksToBeInserted,
+      action.referBlock,
+    ]);
+  }
+  /**
+   * Replaces a specific block with an array of blocks within a RTEContentBlock array.
+   *
+   * @param {RTEListBlock|VegaRTEContent} target - The list block or the VegaRTEContent instance.
+   * @param {RTEBlock} referBlock - Used as a reference block to identify the block that needs to be replaced in the `blocks` array.
+   * @param {RTEBlock[]} blocks - An array of RTEBlock objects that you want to replace the `referBlock` with in the `blocks` array.
+   */
+  replaceBlockWithBlocks(target, referBlock, blocks) {
+    if (target.blocks) {
+      blocks.forEach((block) => {
+        block.parent = target;
+      });
+      const arrayFixed = target.blocks;
+      target.blocks = arrayFixed.flatMap((block) => {
+        if (block === referBlock) {
+          return blocks;
+        }
+        else {
+          return block;
+        }
+      });
+    }
+  }
+}

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

@@ -0,0 +1,31 @@
+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 block into the text block at special position strategy.
+ */
+export class BlockInsertImageIntoTextStrategy extends ActionHandleStrategy {
+  /**
+   * insertImage
+   *
+   * @param {InsertImageToBlockAction} action - Insert image action instance.
+   * @param {RTETextBlock} target - The text block.
+   */
+  handleAction(action, target) {
+    const splitNode = action.splitPointNode;
+    const startOffsetOfNode = action.startOffsetOfNode;
+    const newImageBlock = action.imageBlockToBeInserted;
+    if (this.isCaretPositionAtTextBlockEnd(target, splitNode, startOffsetOfNode)) {
+      target.parent.apply(new InsertBlocksAfterAction(target, newImageBlock));
+    }
+    else if (this.isCaretPositionAtTextBlockStart(target, splitNode, startOffsetOfNode)) {
+      target.parent.apply(new InsertBlocksBeforeAction(target, newImageBlock));
+    }
+    else {
+      const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
+      target.apply(splitBlockAction);
+      target.parent.apply(new InsertBlocksAfterAction(target, newImageBlock));
+    }
+  }
+}

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

@@ -0,0 +1,57 @@
+import { generateUUID } from '../../../../../utils/misc';
+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 current text block at special position strategy.
+ */
+export class BlockInsertLineBreakStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    action.lineBreakNode = this.lineBreakSingleBlock(action.startContainerNode, action.startOffset, target);
+  }
+  /**
+   * lineBreakSingleBlock
+   *
+   * @param {RTETextNode} splitNode -
+   * @param {number} startOffsetOfNode -
+   * @param {RTETextBlock} target -
+   * @returns {Nullable<RTETextNode>} Nullable<RTETextNode>
+   */
+  lineBreakSingleBlock(splitNode, startOffsetOfNode, target) {
+    if (splitNode) {
+      const lineBreakNode = new RTETextNode(generateUUID(), '\n', target);
+      const beforeText = splitNode.text.slice(0, startOffsetOfNode);
+      const afterText = splitNode.text.slice(startOffsetOfNode);
+      const nodesSplitIndex = target.nodes.indexOf(splitNode);
+      if (nodesSplitIndex > -1) {
+        const beforeNodes = target.nodes.slice(0, nodesSplitIndex);
+        const afterNodes = target.nodes.slice(nodesSplitIndex + 1);
+        if (beforeText) {
+          beforeNodes.push(splitNode.cloneWithText(beforeText));
+        }
+        if (afterText) {
+          afterNodes.unshift(splitNode.cloneWithText(afterText));
+        }
+        this.mergeLineBreakNodes(beforeNodes, lineBreakNode, afterNodes, target);
+      }
+      return lineBreakNode;
+    }
+  }
+  /**
+   * 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]));
+  }
+}