@globalpayments/vega 2.58.0 → 2.59.1

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

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

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

@@ -0,0 +1,37 @@
+import { InsertChildrenAfterAction } from '../../actions/insert-children-after-block';
+import { InsertChildrenBeforeAction } from '../../actions/insert-children-before-block';
+import { UpdateCursorPositionAction } from '../../actions/update-cursor-position-action';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Strategy for inserting text into a decorator node. The decorator can not edit, so we insert the text as a new child.
+ */
+export class InsertTextToDecoratorNodeStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const { text, offset, decoratorNode } = action;
+    const paragraph = this.createNewParagraph(text);
+    if (paragraph) {
+      const newTextNode = paragraph.children[0];
+      if (offset !== 0) {
+        target.apply(new InsertChildrenAfterAction(decoratorNode, newTextNode));
+      }
+      else {
+        target.apply(new InsertChildrenBeforeAction(decoratorNode, newTextNode));
+      }
+      this.setTheCursorPosition(newTextNode);
+    }
+  }
+  /**
+   * Set the cursor position to the new text node.
+   *
+   * @param {RTENode} focusNode - The new text node to focus on.
+   */
+  setTheCursorPosition(focusNode) {
+    const rootContent = this.getRootContent(focusNode.parent);
+    if (rootContent) {
+      rootContent.apply(new UpdateCursorPositionAction(focusNode));
+    }
+  }
+}

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

@@ -0,0 +1,31 @@
+import { InternalAnnotationTypeEnum } from '../../annotations/annotation.abstract';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Split the link nodes in the corresponding link group
+ */
+export class LinkGroupNodeSplitStrategy extends ActionHandleStrategy {
+  /**
+   * Split the text node.
+   *
+   * @param {LinkGroupNodeSplitAction} action - The split action.
+   * @param {RTETextNode} target - The text node that need to be splitted.
+   */
+  handleAction(action, target) {
+    const linkGroupAnnotation = target.parent.getAnnotationByType(InternalAnnotationTypeEnum.LINK_GROUP);
+    if (linkGroupAnnotation) {
+      const currentGroupKey = target.annotationMap.get('LINK').link
+        .groupKey;
+      const currentLinkGroup = linkGroupAnnotation.linkGroups.get(currentGroupKey);
+      if (currentLinkGroup) {
+        const index = currentLinkGroup.indexOf(target);
+        if (index !== -1) {
+          /* istanbul ignore next */
+          currentLinkGroup.splice(index, 1, ...(Array.isArray(action.splittedTextNodes)
+            ? action.splittedTextNodes
+            : [action.splittedTextNodes]));
+          linkGroupAnnotation.linkGroups.set(currentGroupKey, currentLinkGroup);
+        }
+      }
+    }
+  }
+}

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

@@ -1,4 +1,4 @@
-import { InsertBlocksAfterAction } from '../../actions/insert-blocks-after-block';
+import { InsertChildrenAfterAction } from '../../actions/insert-children-after-block';
 import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
 /**
  * Insert image to list block strategy.
@@ -13,7 +13,7 @@ export class ListInsertImageStrategy extends ActionHandleStrategy {
   handleAction(action, target) {
     const imageBlock = action.imageBlockToBeInserted;
     if (target.parent['type'] !== 'list-item') {
-      target.parent.apply(new InsertBlocksAfterAction(target, imageBlock));
+      target.parent.apply(new InsertChildrenAfterAction(target, imageBlock));
     }
     else {
       target.parent.apply(action);

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

@@ -1,12 +1,12 @@
-import { generateUUID } from '../../../../../utils/misc';
-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 { RemoveChildAction } from '../../actions/remove-child-action';
+import { AppendChildrenAction } from '../../actions/append-child-nodes-action';
+import { InsertChildrenAfterAction } from '../../actions/insert-children-after-block';
+import { InsertChildrenBeforeAction } from '../../actions/insert-children-before-block';
+import { RemoveChildrenAction } from '../../actions/remove-child-action';
 import { SplitBlockWithNodeAction } from '../../actions/split-block-with-node-action';
 import { NodeAnnotationTypeEnum } from '../../annotations/node-annotation.abstract';
 import { RTETextBlock } from '../../blocks/text-block';
 import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+import { generateUUID } from '../../../../../utils/misc';
 /**
  * Insert new paragraph into current list item block at special position.
  */
@@ -30,12 +30,12 @@ export class ListItemInsertNewParagraphStrategy extends ActionHandleStrategy {
   breakSingleListItemBlock(splitNode, startOffsetOfNode, target) {
     const newListItem = target.createNewListItem();
     const newBreakNode = this.copyInlineStyleToNewNode(splitNode);
-    newListItem.apply(new AppendChildNodesAction([newBreakNode]));
-    if (this.isCaretPositionAtTextBlockEnd(target, splitNode, startOffsetOfNode)) {
+    newListItem.apply(new AppendChildrenAction([newBreakNode]));
+    if (this.isCaretPositionAtBlockEnd(target, splitNode, startOffsetOfNode)) {
       return this.breakListItemAtEnd(newListItem, target);
     }
-    else if (this.isCaretPositionAtTextBlockStart(target, splitNode, startOffsetOfNode)) {
-      target.parent.apply(new InsertBlocksBeforeAction(target, newListItem));
+    else if (this.isCaretPositionAtBlockStart(target, splitNode, startOffsetOfNode)) {
+      target.parent.apply(new InsertChildrenBeforeAction(target, newListItem));
     }
     else {
       const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
@@ -62,18 +62,18 @@ export class ListItemInsertNewParagraphStrategy extends ActionHandleStrategy {
           type: 'paragraph',
           nodes: [],
         });
-        newParagraph.apply(new AppendChildNodesAction(newListItem.children));
-        parentParent.apply(new InsertBlocksAfterAction(target.parent, newParagraph));
-        target.parent.apply(new RemoveChildAction(target));
+        newParagraph.apply(new AppendChildrenAction(newListItem.children));
+        parentParent.apply(new InsertChildrenAfterAction(target.parent, newParagraph));
+        target.parent.apply(new RemoveChildrenAction(target));
         return newParagraph;
       }
       else {
-        parentParent.parent.apply(new InsertBlocksAfterAction(parentParent, newListItem));
-        target.parent.apply(new RemoveChildAction(target));
+        parentParent.parent.apply(new InsertChildrenAfterAction(parentParent, newListItem));
+        target.parent.apply(new RemoveChildrenAction(target));
       }
     }
     else {
-      target.parent.apply(new InsertBlocksAfterAction(target, newListItem));
+      target.parent.apply(new InsertChildrenAfterAction(target, newListItem));
     }
     return newListItem;
   }

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

@@ -1,14 +1,14 @@
-import { RemoveChildAction } from '../../actions/remove-child-action';
+import { RemoveChildrenAction } from '../../actions/remove-child-action';
 import { RemoveNestListAction } from '../../actions/remove-nest-list-action';
-import { BlockRemoveChildBlockStrategy } from './block-remove-child-block-strategy';
+import { RemoveChildrenStrategy } from './remove-children-strategy';
 /**
  * List remove list item strategy.
  */
-export class ListRemoveListItemStrategy extends BlockRemoveChildBlockStrategy {
+export class ListRemoveListItemStrategy extends RemoveChildrenStrategy {
   /**
    * Remove the list item, check the list item and remove self if the list item is empty.
    *
-   * @param {RemoveChildAction} action - The remove action instance.
+   * @param {RemoveChildrenAction} action - The remove action instance.
    * @param {RTEListBlock} target - The list block.
    */
   handleAction(action, target) {
@@ -20,7 +20,7 @@ export class ListRemoveListItemStrategy extends BlockRemoveChildBlockStrategy {
         parent.apply(new RemoveNestListAction(target));
       }
       else {
-        parent.apply(new RemoveChildAction(target));
+        parent.apply(new RemoveChildrenAction(target));
       }
     }
   }

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

@@ -1,6 +1,6 @@
-import { AppendChildNodesAction } from '../../actions/append-child-nodes-action';
-import { InsertBlocksAfterAction } from '../../actions/insert-blocks-after-block';
-import { RemoveChildAction } from '../../actions/remove-child-action';
+import { AppendChildrenAction } from '../../actions/append-child-nodes-action';
+import { InsertChildrenAfterAction } from '../../actions/insert-children-after-block';
+import { RemoveChildrenAction } from '../../actions/remove-child-action';
 import { SyncUpSelectionAction } from '../../actions/sync-up-selection-action';
 import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
 /**
@@ -16,20 +16,20 @@ export class ListTransformToListStrategy extends ActionHandleStrategy {
     const isSameList = selectedBlocks.every((block) => block.parent === target);
     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(target.children));
-      target.parent.apply(new InsertBlocksAfterAction(target, bulletList));
-      target.parent.apply(new RemoveChildAction(target));
+      bulletList.apply(new AppendChildrenAction(target.children));
+      target.parent.apply(new InsertChildrenAfterAction(target, bulletList));
+      target.parent.apply(new RemoveChildrenAction(target));
       selectedBlocks.forEach((block) => block.children.map((node) => node.apply(new SyncUpSelectionAction())));
     }
     else {
       const listItems = action.selectedBlocks.map((block) => target.parent.toListItem(block));
-      bulletList.apply(new AppendChildNodesAction(listItems));
-      target.parent.apply(new InsertBlocksAfterAction(target, bulletList));
+      bulletList.apply(new AppendChildrenAction(listItems));
+      target.parent.apply(new InsertChildrenAfterAction(target, bulletList));
       action.selectedBlocks.forEach((block) => {
-        block.parent.apply(new RemoveChildAction(block));
+        block.parent.apply(new RemoveChildrenAction(block));
       });
       if (target.children.length === 0) {
-        target.parent.apply(new RemoveChildAction(target));
+        target.parent.apply(new RemoveChildrenAction(target));
       }
     }
   }

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

@@ -1,8 +1,8 @@
 import { generateUUID } from '../../../../../utils/misc';
-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 { RemoveChildAction } from '../../actions/remove-child-action';
+import { AppendChildrenAction } from '../../actions/append-child-nodes-action';
+import { InsertChildrenAfterAction } from '../../actions/insert-children-after-block';
+import { InsertChildrenBeforeAction } from '../../actions/insert-children-before-block';
+import { RemoveChildrenAction } from '../../actions/remove-child-action';
 import { SyncUpSelectionAction } from '../../actions/sync-up-selection-action';
 import { RTETextBlock } from '../../blocks/text-block';
 import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
@@ -26,26 +26,26 @@ export class ListTransformToParagraphStrategy extends ActionHandleStrategy {
       return this.toParagraph(block);
     });
     if (isSelectedFirstBlock) {
-      target.parent.apply(new InsertBlocksBeforeAction(target, ...currentParagraph));
+      target.parent.apply(new InsertChildrenBeforeAction(target, ...currentParagraph));
     }
     else if (isSelectedLastBlock) {
-      target.parent.apply(new InsertBlocksAfterAction(target, ...currentParagraph));
+      target.parent.apply(new InsertChildrenAfterAction(target, ...currentParagraph));
     }
     else {
       const startIndex = target.children.indexOf(selectedBlocks[0]);
       const lastIndex = target.children.indexOf(selectedBlocks[selectedBlocks.length - 1]);
       const firstBulletList = target.parent.createList(target.type);
-      firstBulletList.apply(new AppendChildNodesAction(target.children.slice(0, startIndex)));
+      firstBulletList.apply(new AppendChildrenAction(target.children.slice(0, startIndex)));
       const lastBulletList = target.parent.createList(target.type);
-      lastBulletList.apply(new AppendChildNodesAction(target.children.slice(lastIndex + 1)));
-      target.parent.apply(new InsertBlocksBeforeAction(target, firstBulletList, ...currentParagraph, lastBulletList));
-      target.parent.apply(new RemoveChildAction(target));
+      lastBulletList.apply(new AppendChildrenAction(target.children.slice(lastIndex + 1)));
+      target.parent.apply(new InsertChildrenBeforeAction(target, firstBulletList, ...currentParagraph, lastBulletList));
+      target.parent.apply(new RemoveChildrenAction(target));
     }
     selectedBlocks.map((block) => {
-      target.apply(new RemoveChildAction(block));
+      target.apply(new RemoveChildrenAction(block));
     });
     if (target.children.length === 0) {
-      target.parent.apply(new RemoveChildAction(target));
+      target.parent.apply(new RemoveChildrenAction(target));
     }
   }
   /**
@@ -56,7 +56,7 @@ export class ListTransformToParagraphStrategy extends ActionHandleStrategy {
    */
   toParagraph(block) {
     const textBlock = new RTETextBlock(generateUUID(), 'paragraph');
-    textBlock.apply(new AppendChildNodesAction(block['children']));
+    textBlock.apply(new AppendChildrenAction(block['children']));
     textBlock['annotationMap'] = block['annotationMap'];
     return textBlock;
   }

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

@@ -1,4 +1,4 @@
-import { NodeAnnotationTypeEnum } from '../../annotations/node-annotation.abstract';
+import { DeleteLinkGroupAction } from '../../actions/delete-link-group-action';
 import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
 /**
  * Update the editor text node text content strategy.
@@ -14,7 +14,7 @@ export class NodeUpdateTextStrategy extends ActionHandleStrategy {
     target.text = action.newTextContent;
     // The link node should unlink when delete all text
     if (!target.text && target.annotationMap.has('LINK')) {
-      target.annotationMap.delete(NodeAnnotationTypeEnum.LINK);
+      target.apply(new DeleteLinkGroupAction());
     }
   }
 }

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

@@ -0,0 +1,26 @@
+import { RemoveChildrenAction } 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 RemoveChildrenStrategy extends ActionHandleStrategy {
+  /**
+   * Remove the node or block from the parent.
+   * Remove the block if the block children is empty after delete the current element.
+   *
+   * @param {RemoveChildrenAction} action - The remove child action instance.
+   * @param {RTEBlock | VegaRTEContent} target - The parent block of the node that will be removed.
+   */
+  handleAction(action, target) {
+    const arrayFixed = target.children;
+    target.children = arrayFixed.filter((node) => node !== action.entityToBeRemoved);
+    if (target.children.length === 0 && 'parent' in target && target.parent) {
+      if (!target.isListItemBlock()) {
+        target.parent.apply(new RemoveChildrenAction(target));
+      }
+      else if (!target.nestList || !target.nestList.length) {
+        target.parent.apply(new RemoveChildrenAction(target));
+      }
+    }
+  }
+}

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

@@ -3,7 +3,7 @@ import domNodeSubjectFactory from '../../../../../helpers/change-manager/subject
 import { VegaInternalRichTextEditorSelectionRangeChange } from '../../../../../helpers/event-manager/event-id/vega-internal-event-id';
 import { generateUUID } from '../../../../../utils/misc';
 import stateEntityRenderingRegistry from '../../../slimmers/controllers/state-entity-rendering-registry';
-import { InsertBlocksAfterAction } from '../../actions/insert-blocks-after-block';
+import { InsertChildrenAfterAction } from '../../actions/insert-children-after-block';
 import { UpdateCodeBlockAction } from '../../actions/update-code-block-action';
 import { RTETextBlock } from '../../blocks/text-block';
 import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
@@ -25,7 +25,7 @@ export class SwitchOutFromCodeBlockStrategy extends ActionHandleStrategy {
       type: 'paragraph',
       nodes: [{ id: generateUUID(), text: '', type: 'text' }],
     });
-    target.parent.apply(new InsertBlocksAfterAction(target, textBlock));
+    target.parent.apply(new InsertChildrenAfterAction(target, textBlock));
     // Focus the next text node after value update.
     const currentNodeDom = stateEntityRenderingRegistry.getDOMByEntity(target);
     if (currentNodeDom) {

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

@@ -0,0 +1,23 @@
+import changeManager from '../../../../../helpers/change-manager/change-manager';
+import domNodeSubjectFactory from '../../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-factory';
+import { VegaInternalUpdateRTECursorPosition } from '../../../../../helpers/event-manager/event-id/vega-internal-event-id';
+import stateEntityRenderingRegistry from '../../../slimmers/controllers/state-entity-rendering-registry';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Update the cursor position in the editor.
+ */
+export class UpdateCursorPositionStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const { offset, nextFocusNode } = action;
+    const host = stateEntityRenderingRegistry.getDOMByEntity(target);
+    if (host) {
+      changeManager.notify(domNodeSubjectFactory.getSubject(host, VegaInternalUpdateRTECursorPosition), {
+        node: nextFocusNode,
+        offset,
+      });
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/actions/append-child-nodes-action.js

@@ -1,9 +1,13 @@
 import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
-/** Append blocks or nodes to a block */
-export class AppendChildNodesAction extends ModifyContentAction {
+/**
+ * Append children to a block or rte content
+ *
+ * @example parent.apply(new AppendChildrenAction([newChildren]))
+ */
+export class AppendChildrenAction extends ModifyContentAction {
   constructor(childNodes) {
     super();
-    this.type = ModifyContentActionType.APPEND_CHILD_NODES;
+    this.type = ModifyContentActionType.APPEND_CHILDREN;
     this.entityToBeAppended = childNodes;
   }
 }

package/dist/collection/components/vega-rich-text-editor/dto/actions/custom-style-annotation-action.js

@@ -0,0 +1,20 @@
+import { AnnotationAction } from './annotation-action.abstract';
+import { CustomStyleAnnotation } from '../annotations/custom-style-annotation';
+/**
+ * Action to toggle block horizontal alignment annotation
+ */
+export class CustomStyleAnnotationAction extends AnnotationAction {
+  constructor(customStyle) {
+    super();
+    this.isFlushable = true;
+    this.customStyle = customStyle;
+  }
+  /**
+   * Converts the action to an annotation
+   *
+   * @returns {CustomStyleAnnotation} The annotation
+   */
+  toAnnotation() {
+    return new CustomStyleAnnotation(this.customStyle);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/actions/delete-link-group-action.js

@@ -0,0 +1,10 @@
+import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
+/**
+ * Delete the corresponding link group according to the text node *
+ */
+export class DeleteLinkGroupAction extends ModifyContentAction {
+  constructor() {
+    super(...arguments);
+    this.type = ModifyContentActionType.DELETE_LINK_GROUP;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/actions/insert-children-after-block.js

@@ -0,0 +1,14 @@
+import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
+/**
+ * Insert a new children after a existing children
+ *
+ * @example parent.apply(new InsertChildrenAfterAction(existingChildren, newChildren, ...))
+ */
+export class InsertChildrenAfterAction extends ModifyContentAction {
+  constructor(referBlock, ...blocksToBeInserted) {
+    super();
+    this.type = ModifyContentActionType.INSERT_CHILDREN_AFTER;
+    this.referChildren = referBlock;
+    this.childrenToBeInserted = blocksToBeInserted;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/actions/insert-children-before-block.js

@@ -0,0 +1,14 @@
+import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
+/**
+ * Insert a children before a existing children
+ *
+ * @example parent.apply(new InsertChildrenBeforeAction(existingChildren, newChildren, ...))
+ */
+export class InsertChildrenBeforeAction extends ModifyContentAction {
+  constructor(referChildren, ...childrenToBeInserted) {
+    super();
+    this.type = ModifyContentActionType.INSERT_CHILDREN_BEFORE;
+    this.referChildren = referChildren;
+    this.childrenToBeInserted = childrenToBeInserted;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/actions/{break-single-block-action.js → insert-new-paragraph-action.js}

@@ -4,12 +4,12 @@ import { ModifyContentAction, ModifyContentActionType } from './modify-content-a
  * The SplitBlockWithNodeAction split the current block to two same type blocks, but this action will create new paragraph or list item when break at start or end.
  * The property `newBlock` use to store the new create block if need.
  *
- * @example currentBlock.apply(new BreakSingleBlockAction(startContainerNode, startOffset))
+ * @example currentBlock.apply(new InsertNewParagraphAction(startContainerNode, startOffset))
  */
-export class BreakSingleBlockAction extends ModifyContentAction {
+export class InsertNewParagraphAction extends ModifyContentAction {
   constructor(startContainerNode, startOffset) {
     super();
-    this.type = ModifyContentActionType.BREAK_SINGLE_BLOCK;
+    this.type = ModifyContentActionType.INSERT_NEW_PARAGRAPH;
     this.startContainerNode = startContainerNode;
     this.startOffset = startOffset;
   }

package/dist/collection/components/vega-rich-text-editor/dto/actions/insert-text-to-decorator-node-action.js

@@ -0,0 +1,17 @@
+import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
+/**
+ * Action to type character into a decorator node
+ *
+ * @example decoratorNode.parent.apply(new InsertTextToDecoratorNodeAction(decoratorNode, '', 0 | 1))
+ */
+export class InsertTextToDecoratorNodeAction extends ModifyContentAction {
+  constructor(decoratorNode, text, offset) {
+    super();
+    this.type = ModifyContentActionType.INSERT_TEXT_TO_DECORATOR_NODE;
+    this.text = '';
+    this.offset = 0;
+    this.decoratorNode = decoratorNode;
+    this.text = text;
+    this.offset = offset;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/actions/link-annotation-action.js

@@ -5,12 +5,13 @@ import { isNonNullable } from '../../../../types/type-guard';
  * Action to toggle link annotation
  */
 export class LinkAnnotationAction extends TextSplittableAction {
-  constructor({ link, newText, needMergeNode, doSplit, }) {
+  constructor({ link, newText, needMergeNode, doSplit, type, }) {
     super();
     this.isFlushable = true;
     this.link = link;
     this.needMergeNode = needMergeNode;
     this.newText = newText;
+    this.type = type;
     if (isNonNullable(doSplit)) {
       this.doSplit = doSplit;
     }

package/dist/collection/components/vega-rich-text-editor/dto/actions/link-group-annotation-action.js

@@ -4,11 +4,12 @@ import { LinkGroupAnnotation } from '../annotations/link-group-annotation';
  * Action to link a group of nodes
  */
 export class LinkGroupAnnotationAction extends AnnotationAction {
-  constructor(groupKey, nodes) {
+  constructor(groupKey, nodes, type) {
     super();
     this.isFlushable = false;
     this.groupKey = groupKey;
     this.nodes = nodes;
+    this.type = type;
   }
   /**
    * Converts the action to an annotation

package/dist/collection/components/vega-rich-text-editor/dto/actions/link-group-node-split-action.js

@@ -0,0 +1,11 @@
+import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
+/**
+ * Split the corresponding link group nodes *
+ */
+export class LinkGroupNodeSplitAction extends ModifyContentAction {
+  constructor(splittedTextNodes) {
+    super();
+    this.type = ModifyContentActionType.LINK_GROUP_NODE_SPLIT;
+    this.splittedTextNodes = splittedTextNodes;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/actions/modify-content-action.abstract.js

@@ -1,19 +1,17 @@
 export var ModifyContentActionType;
 (function (ModifyContentActionType) {
-  ModifyContentActionType["DELETE_CHILD"] = "DELETE_CHILD";
+  ModifyContentActionType["DELETE_CHILDREN"] = "DELETE_CHILDREN";
   ModifyContentActionType["DELETE_NEST_LIST"] = "DELETE_NEST_LIST";
   ModifyContentActionType["UPDATE_TEXT"] = "UPDATE_TEXT";
   ModifyContentActionType["REPLACE_SELECTED_TEXT"] = "REPLACE_SELECTED_TEXT";
-  ModifyContentActionType["APPEND_CHILD_NODES"] = "APPEND_CHILD_NODES";
-  ModifyContentActionType["INSERT_BLOCKS_AFTER"] = "INSERT_BLOCKS_AFTER";
-  ModifyContentActionType["INSERT_BLOCKS_BEFORE"] = "INSERT_BLOCKS_BEFORE";
-  ModifyContentActionType["INSERT_NODES_AFTER"] = "INSERT_NODES_AFTER";
-  ModifyContentActionType["INSERT_NODES_BEFORE"] = "INSERT_NODES_BEFORE";
+  ModifyContentActionType["APPEND_CHILDREN"] = "APPEND_CHILDREN";
+  ModifyContentActionType["INSERT_CHILDREN_AFTER"] = "INSERT_CHILDREN_AFTER";
+  ModifyContentActionType["INSERT_CHILDREN_BEFORE"] = "INSERT_CHILDREN_BEFORE";
   ModifyContentActionType["SPLIT_BLOCK_WITH_NODE"] = "SPLIT_BLOCK_WITH_NODE";
   ModifyContentActionType["REPLACE_CHILD_NODES"] = "REPLACE_CHILD_NODES";
   ModifyContentActionType["REPLACE_NEST_LIST"] = "REPLACE_NEST_LIST";
   ModifyContentActionType["MERGE_TWO_BLOCKS_NODES"] = "MERGE_TWO_BLOCKS_NODES";
-  ModifyContentActionType["BREAK_SINGLE_BLOCK"] = "BREAK_SINGLE_BLOCK";
+  ModifyContentActionType["INSERT_NEW_PARAGRAPH"] = "INSERT_NEW_PARAGRAPH";
   ModifyContentActionType["LINE_BREAK_SINGLE_BLOCK"] = "LINE_BREAK_SINGLE_BLOCK";
   ModifyContentActionType["LINE_BREAK_MULTIPLE_BLOCKS"] = "LINE_BREAK_MULTIPLE_BLOCKS";
   ModifyContentActionType["TRANSFORM_LIST_BLOCK"] = "TRANSFORM_LIST_BLOCK";
@@ -25,6 +23,11 @@ export var ModifyContentActionType;
   ModifyContentActionType["UPDATE_CODE_BLOCK"] = "UPDATE_CODE_BLOCK";
   ModifyContentActionType["SWITCH_OUT_FROM_CODE_BLOCK"] = "SWITCH_OUT_FROM_CODE_BLOCK";
   ModifyContentActionType["DELETE_CODE_BLOCK"] = "DELETE_CODE_BLOCK";
+  ModifyContentActionType["UNLINK_LINK_GROUP"] = "UNLINK_LINK_GROUP";
+  ModifyContentActionType["LINK_GROUP_NODE_SPLIT"] = "LINK_GROUP_NODE_SPLIT";
+  ModifyContentActionType["DELETE_LINK_GROUP"] = "DELETE_LINK_GROUP";
+  ModifyContentActionType["UPDATE_CURSOR_POSITION"] = "UPDATE_CURSOR_POSITION";
+  ModifyContentActionType["INSERT_TEXT_TO_DECORATOR_NODE"] = "INSERT_TEXT_TO_DECORATOR_NODE";
 })(ModifyContentActionType || (ModifyContentActionType = {}));
 /**
  * Abstract class for update node content, delete node, insert node

package/dist/collection/components/vega-rich-text-editor/dto/actions/remove-child-action.js

@@ -1,14 +1,13 @@
 import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
 /**
- * Delete child node or child block from the current list action
+ * Remove a children from the current block
  *
- * @example needRemovedNode.parentBlock.apply(new RemoveChildAction(needRemovedNode))
- * @example needRemovedBlock.parent.apply(new RemoveChildAction(needRemovedBlock))
+ * @example needRemovedChildren.parent.apply(new RemoveChildrenAction(needRemovedChildren))
  */
-export class RemoveChildAction extends ModifyContentAction {
+export class RemoveChildrenAction extends ModifyContentAction {
   constructor(childNode) {
     super();
-    this.type = ModifyContentActionType.DELETE_CHILD;
+    this.type = ModifyContentActionType.DELETE_CHILDREN;
     this.entityToBeRemoved = childNode;
   }
 }

package/dist/collection/components/vega-rich-text-editor/dto/actions/unlink-link-group-action.js

@@ -0,0 +1,11 @@
+import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
+/**
+ * Unlink the corresponding link group according to the group key *
+ */
+export class UnlinkLinkGroupAction extends ModifyContentAction {
+  constructor(groupKey) {
+    super();
+    this.type = ModifyContentActionType.UNLINK_LINK_GROUP;
+    this.groupKey = groupKey;
+  }
+}