@globalpayments/vega 2.37.2 → 2.39.0

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

@@ -0,0 +1,92 @@
+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 { 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';
+/**
+ * Insert new paragraph into current list item block at special position.
+ */
+export class ListItemInsertNewParagraphStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    action.newBlock = this.breakSingleListItemBlock(action.startContainerNode, action.startOffset, target);
+  }
+  /**
+   * Breaks a single list item block at a specific position.
+   *
+   * @param {RTETextNode} splitNode - The node that needs to be split within a list item block.
+   * @param {number} startOffsetOfNode - The index within the `splitNode` where the break operation should occur.
+   * @param {RTEListItemBlock} target - The list item block.
+   * @returns {Nullable<RTEBlock>} Returns either a new `RTEListItemBlock` if the caret
+   * position is at the end of the `splitNode`, or it returns the result of splitting the block at the
+   * caret position if it is neither at the start nor at the end.
+   */
+  breakSingleListItemBlock(splitNode, startOffsetOfNode, target) {
+    const newListItem = target.createNewListItem();
+    const newBreakNode = this.copyInlineStyleToNewNode(splitNode);
+    newListItem.apply(new AppendChildNodesAction([newBreakNode]));
+    if (this.isCaretPositionAtTextBlockEnd(target, splitNode, startOffsetOfNode)) {
+      return this.breakListItemAtEnd(newListItem, target);
+    }
+    else if (this.isCaretPositionAtTextBlockStart(target, splitNode, startOffsetOfNode)) {
+      target.parent.apply(new InsertBlocksBeforeAction(target, newListItem));
+    }
+    else {
+      const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
+      target.apply(splitBlockAction);
+      return splitBlockAction.newBlock;
+    }
+    return newListItem;
+  }
+  /**
+   * Breaks a list item at the end and handles the insertion of a new list item or paragraph accordingly.
+   *
+   * @param {RTEListItemBlock} newListItem - Item that represents a new list item to be added to the existing list.
+   * @param {RTEListItemBlock} target - The list item block.
+   * @returns {RTEBlock} Returns a `RTEBlock`.
+   */
+  breakListItemAtEnd(newListItem, target) {
+    const lastItem = target.parent.blocks[target.parent.blocks.length - 1];
+    const currentItemIsEmpty = target.nodes.length === 1 && target.nodes[0].isEmpty();
+    if (target === lastItem && currentItemIsEmpty) {
+      const parentParent = target.parent.parent;
+      if (parentParent['type'] !== 'list-item') {
+        const newParagraph = RTETextBlock.from({
+          id: generateUUID(),
+          type: 'paragraph',
+          nodes: [],
+        });
+        newParagraph.apply(new AppendChildNodesAction(newListItem.nodes));
+        parentParent.apply(new InsertBlocksAfterAction(target.parent, newParagraph));
+        target.parent.apply(new RemoveChildAction(target));
+        return newParagraph;
+      }
+      else {
+        parentParent.parent.apply(new InsertBlocksAfterAction(parentParent, newListItem));
+        target.parent.apply(new RemoveChildAction(target));
+      }
+    }
+    else {
+      target.parent.apply(new InsertBlocksAfterAction(target, newListItem));
+    }
+    return newListItem;
+  }
+  /**
+   * Copy the inline style to new node
+   *
+   * @param {RTETextNode} needCopedNode - The node that needed to be copied to
+   * @returns {RTETextNode} Returns a `RTETextNode`.
+   */
+  copyInlineStyleToNewNode(needCopedNode) {
+    const textNode = needCopedNode.cloneWithText('');
+    // The link annotation doesn't need to inherit
+    textNode.annotationMap.delete(NodeAnnotationTypeEnum.LINK);
+    return textNode;
+  }
+}

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

@@ -0,0 +1,22 @@
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Remove list item nest list block strategy.
+ */
+export class ListItemRemoveNestListStrategy extends ActionHandleStrategy {
+  /**
+   * Remove the nest list block from the list item, clear the property children when the children is empty.
+   *
+   * @param {RemoveNestListAction} action - The action instance.
+   * @param {RTEListItemBlock} target - The list item block.
+   */
+  handleAction(action, target) {
+    if (target.children) {
+      if (target.children.length > 1) {
+        target.children = target.children.filter((child) => child !== action.nestListBlockToBeRemoved);
+      }
+      else {
+        target.children = undefined;
+      }
+    }
+  }
+}

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

@@ -0,0 +1,19 @@
+import { RemoveChildAction } from '../../actions/remove-child-action';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Remove list item child node strategy.
+ */
+export class ListItemRemoveNodeStrategy extends ActionHandleStrategy {
+  /**
+   * Remove child node from the list item, remove the list item if the list item is empty.
+   *
+   * @param {RemoveChildAction} action - The remove child action instance.
+   * @param {RTEListItemBlock} target - The list item block.
+   */
+  handleAction(action, target) {
+    target.nodes = target.nodes.filter((node) => node !== action.entityToBeRemoved);
+    if (target.nodes.length === 0 && (!target.children || !target.children.length)) {
+      target.parent.apply(new RemoveChildAction(target));
+    }
+  }
+}

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

@@ -0,0 +1,15 @@
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Replace list item nest list strategy.
+ */
+export class ListItemReplaceNestListStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    action.newList.forEach((listBlock) => {
+      listBlock.parent = target;
+    });
+    target.children = action.newList;
+  }
+}

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

@@ -0,0 +1,27 @@
+import { RemoveChildAction } from '../../actions/remove-child-action';
+import { RemoveNestListAction } from '../../actions/remove-nest-list-action';
+import { BlockRemoveChildBlockStrategy } from './block-remove-child-block-strategy';
+/**
+ * List remove list item strategy.
+ */
+export class ListRemoveListItemStrategy extends BlockRemoveChildBlockStrategy {
+  /**
+   * 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 {RTEListBlock} target - The list block.
+   */
+  handleAction(action, target) {
+    super.handleAction(action, target);
+    const parent = target.parent;
+    if (target.blocks.length === 0 && 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 (parent['type'] === 'list-item') {
+        parent.apply(new RemoveNestListAction(target));
+      }
+      else {
+        parent.apply(new RemoveChildAction(target));
+      }
+    }
+  }
+}

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

@@ -0,0 +1,36 @@
+import { AppendChildNodesAction } from '../../actions/append-child-nodes-action';
+import { InsertBlocksAfterAction } from '../../actions/insert-blocks-after-block';
+import { RemoveChildAction } from '../../actions/remove-child-action';
+import { SyncUpSelectionAction } from '../../actions/sync-up-selection-action';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Convert the selected blocks to list strategy.
+ */
+export class ListTransformToListStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const selectedBlocks = action.selectedBlocks;
+    const bulletList = target.parent.createList(action.listType);
+    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.blocks));
+      target.parent.apply(new InsertBlocksAfterAction(target, bulletList));
+      target.parent.apply(new RemoveChildAction(target));
+      selectedBlocks.forEach((block) => block.nodes.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));
+      action.selectedBlocks.forEach((block) => {
+        block.parent.apply(new RemoveChildAction(block));
+      });
+      if (target.blocks.length === 0) {
+        target.parent.apply(new RemoveChildAction(target));
+      }
+    }
+  }
+}

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

@@ -0,0 +1,63 @@
+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 { SyncUpSelectionAction } from '../../actions/sync-up-selection-action';
+import { RTETextBlock } from '../../blocks/text-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Convert the selected list block to paragraph strategy.
+ */
+export class ListTransformToParagraphStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    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 === target.blocks[0])
+        isSelectedFirstBlock = true;
+      if (block === target.blocks[target.blocks.length - 1])
+        isSelectedLastBlock = true;
+      return this.toParagraph(block);
+    });
+    if (isSelectedFirstBlock) {
+      target.parent.apply(new InsertBlocksBeforeAction(target, ...currentParagraph));
+    }
+    else if (isSelectedLastBlock) {
+      target.parent.apply(new InsertBlocksAfterAction(target, ...currentParagraph));
+    }
+    else {
+      const startIndex = target.blocks.indexOf(selectedBlocks[0]);
+      const lastIndex = target.blocks.indexOf(selectedBlocks[selectedBlocks.length - 1]);
+      const firstBulletList = target.parent.createList(target.type);
+      firstBulletList.apply(new AppendChildNodesAction(target.blocks.slice(0, startIndex)));
+      const lastBulletList = target.parent.createList(target.type);
+      lastBulletList.apply(new AppendChildNodesAction(target.blocks.slice(lastIndex + 1)));
+      target.parent.apply(new InsertBlocksBeforeAction(target, firstBulletList, ...currentParagraph, lastBulletList));
+      target.parent.apply(new RemoveChildAction(target));
+    }
+    selectedBlocks.map((block) => {
+      target.apply(new RemoveChildAction(block));
+    });
+    if (target.blocks.length === 0) {
+      target.parent.apply(new RemoveChildAction(target));
+    }
+  }
+  /**
+   * 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;
+  }
+}

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

@@ -0,0 +1,46 @@
+import stateEntityRenderingRegistry from '../../../slimmers/controllers/state-entity-rendering-registry';
+import { UpdateTextAction } from '../../actions/update-text-action';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Replaces the rich text node selected text strategy.
+ */
+export class NodeReplaceSelectedTextStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    this.replaceSelectedText(action.textToBeInsert, action.currentRange, target);
+  }
+  /**
+   * Replaces the selected text within a given range with a new text in a TypeScript class.
+   *
+   * @param {string} text - The new text that will replace the currently selected text within the specified range.
+   * @param {RTERange} currentRange - A range of text within a Rich Text Editor (RTE).
+   * @param {RTETextNode} target - The RTE text node instance.
+   */
+  replaceSelectedText(text, currentRange, target) {
+    if (currentRange && currentRange.startContainer && currentRange.endContainer) {
+      const { startContainer, endContainer, startOffset, endOffset } = currentRange;
+      let newText = target.text;
+      if (startContainer === endContainer && startOffset === endOffset && text) {
+        newText = target.text.slice(0, startOffset) + text + target.text.slice(startOffset);
+      }
+      else {
+        const startNode = startContainer.parentElement;
+        const endNode = endContainer.parentElement;
+        const startItemDto = startNode && stateEntityRenderingRegistry.getEntityByDOM(startNode);
+        const endItemDto = endNode && stateEntityRenderingRegistry.getEntityByDOM(endNode);
+        let startIndex = 0, endIndex = target.text.length;
+        if (startItemDto && startItemDto === target) {
+          startIndex = startOffset;
+          endIndex = startContainer === endContainer ? endOffset : endIndex;
+        }
+        else if (endItemDto && endItemDto === target) {
+          endIndex = endOffset;
+        }
+        newText = target.text.slice(0, startIndex) + text + target.text.slice(endIndex);
+      }
+      target.apply(new UpdateTextAction(newText));
+    }
+  }
+}

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

@@ -0,0 +1,20 @@
+import { NodeAnnotationTypeEnum } from '../../annotations/node-annotation.abstract';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Update the editor text node text content strategy.
+ */
+export class NodeUpdateTextStrategy extends ActionHandleStrategy {
+  /**
+   * Updates the text content of a node and unlink the node if it is a link node and the text is deleted.
+   *
+   * @param {UpdateTextAction} action - The update text action instance.
+   * @param {RTETextNode} target - The text node instance which need update the text.
+   */
+  handleAction(action, target) {
+    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);
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/actions/image-update-url-action.js

@@ -0,0 +1,13 @@
+import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
+/**
+ * Update the image node property url after the image uploaded.
+ *
+ * @example currentImageNode.apply(new ImageUpdateUrlAction(url))
+ */
+export class ImageUpdateUrlAction extends ModifyContentAction {
+  constructor(newUrl) {
+    super();
+    this.type = ModifyContentActionType.UPDATE_IMAGE_NODE_URL;
+    this.url = newUrl;
+  }
+}

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

@@ -5,7 +5,6 @@ export var ModifyContentActionType;
   ModifyContentActionType["UPDATE_TEXT"] = "UPDATE_TEXT";
   ModifyContentActionType["REPLACE_SELECTED_TEXT"] = "REPLACE_SELECTED_TEXT";
   ModifyContentActionType["APPEND_CHILD_NODES"] = "APPEND_CHILD_NODES";
-  ModifyContentActionType["CLEAR_CHILD_NODES"] = "CLEAR_CHILD_NODES";
   ModifyContentActionType["INSERT_BLOCKS_AFTER"] = "INSERT_BLOCKS_AFTER";
   ModifyContentActionType["INSERT_BLOCKS_BEFORE"] = "INSERT_BLOCKS_BEFORE";
   ModifyContentActionType["INSERT_NODES_AFTER"] = "INSERT_NODES_AFTER";
@@ -21,6 +20,7 @@ export var ModifyContentActionType;
   ModifyContentActionType["TRANSFORM_PARAGRAPH_BLOCK"] = "TRANSFORM_PARAGRAPH_BLOCK";
   ModifyContentActionType["DELETE_BLOCK_CONTENT"] = "DELETE_BLOCK_CONTENT";
   ModifyContentActionType["INSERT_IMAGE_TO_BLOCK"] = "INSERT_IMAGE_TO_BLOCK";
+  ModifyContentActionType["UPDATE_IMAGE_NODE_URL"] = "UPDATE_IMAGE_NODE_URL";
 })(ModifyContentActionType || (ModifyContentActionType = {}));
 /**
  * Abstract class for update node content, delete node, insert node

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

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