@globalpayments/vega 2.55.1 → 2.56.0

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

@@ -10,10 +10,10 @@ export class BlockDeleteNodeContentStrategy extends ActionHandleStrategy {
    * @returns {Nullable<RTENode>} the previous block last node
    */
   getPreviousNode(currentNode) {
-    const currentBlock = currentNode.parentBlock;
-    const currentIndex = currentBlock['nodes'].indexOf(currentNode);
+    const currentBlock = currentNode.parent;
+    const currentIndex = currentBlock.children.indexOf(currentNode);
     if (currentIndex > 0) {
-      return currentBlock['nodes'][currentIndex - 1];
+      return currentBlock.children[currentIndex - 1];
     }
     else if (currentBlock.parent) {
       const previousBlock = this.getPreviousBlock(currentBlock);
@@ -29,10 +29,10 @@ export class BlockDeleteNodeContentStrategy extends ActionHandleStrategy {
    * @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];
+    const currentBlock = currentNode.parent;
+    const currentIndex = currentBlock.children.indexOf(currentNode);
+    if (currentBlock.children[currentIndex + 1]) {
+      return currentBlock.children[currentIndex + 1];
     }
     else if (currentBlock.parent) {
       const nextBlock = this.getNextBlock(currentBlock);
@@ -48,20 +48,20 @@ export class BlockDeleteNodeContentStrategy extends ActionHandleStrategy {
    * @returns {boolean} True or false;
    */
   isContentFirstNode(currentNode) {
-    const currentBlock = currentNode.parentBlock;
-    const currentIndex = currentBlock['nodes'].indexOf(currentNode);
+    const currentBlock = currentNode.parent;
+    const currentIndex = currentBlock.children.indexOf(currentNode);
     const parent = currentBlock.parent;
-    if (currentBlock.type === 'list-item') {
+    if (currentBlock.isListItemBlock()) {
       const listParent = parent.parent;
       return (currentIndex === 0 &&
-        Array.isArray(parent['blocks']) &&
-        parent['blocks'][0] === currentBlock &&
+        Array.isArray(parent.children) &&
+        parent.children[0] === currentBlock &&
         listParent['type'] !== 'list-item' &&
-        Array.isArray(listParent['blocks']) &&
-        listParent['blocks'][0] === parent);
+        Array.isArray(listParent.children) &&
+        listParent.children[0] === parent);
     }
     else {
-      return (currentIndex === 0 && Array.isArray(parent['blocks']) && parent['blocks'][0] === currentBlock);
+      return (currentIndex === 0 && Array.isArray(parent.children) && parent.children[0] === currentBlock);
     }
   }
   /**
@@ -72,10 +72,10 @@ export class BlockDeleteNodeContentStrategy extends ActionHandleStrategy {
    * @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 (currentBlock && currentBlock.parent && currentBlock.parent.children) {
+      const currentBlockIndex = currentBlock.parent.children.indexOf(currentBlock);
       if (currentBlockIndex > 0) {
-        return currentBlock.parent['blocks'][currentBlockIndex - 1];
+        return currentBlock.parent.children[currentBlockIndex - 1];
       }
       else if ((currentBlock.parent['type'] === 'number-list' ||
         currentBlock.parent['type'] === 'bullet-list') &&
@@ -91,26 +91,7 @@ export class BlockDeleteNodeContentStrategy extends ActionHandleStrategy {
    * @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];
-      }
-    }
+    return currentBlock.getLastNode();
   }
   /**
    * Returns the first node within a given RTE block, handling different block types accordingly.
@@ -120,14 +101,14 @@ export class BlockDeleteNodeContentStrategy extends ActionHandleStrategy {
    */
   getBlockFirstNode(currentBlock) {
     if (currentBlock.type === 'number-list' || currentBlock.type === 'bullet-list') {
-      if (currentBlock.blocks) {
-        const firstListItem = currentBlock.blocks[0];
+      if (currentBlock.children) {
+        const firstListItem = currentBlock.children[0];
         return this.getBlockFirstNode(firstListItem);
       }
     }
     else {
-      if (currentBlock['nodes']) {
-        return currentBlock['nodes'][0];
+      if (currentBlock.children) {
+        return currentBlock.children[0];
       }
     }
   }
@@ -138,13 +119,13 @@ export class BlockDeleteNodeContentStrategy extends ActionHandleStrategy {
    * @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];
+    if (currentBlock && currentBlock.parent && currentBlock.parent.children) {
+      const currentBlockIndex = currentBlock.parent.children.indexOf(currentBlock);
+      if (currentBlock.parent.children[currentBlockIndex + 1]) {
+        return currentBlock.parent.children[currentBlockIndex + 1];
       }
       else if (currentBlock.type === 'list-item' &&
-        currentBlock.parent.blocks.length === currentBlockIndex + 1) {
+        currentBlock.parent.children.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

@@ -33,8 +33,8 @@ export class BlockDeleteTextContentStrategy extends BlockDeleteNodeContentStrate
       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) {
+        if ((previousNode && previousNode.parent === target && previousNode['text'] === '\n') ||
+          target.children.length === 1) {
           action.previousNode = startContainerNode;
           return;
         }
@@ -48,12 +48,12 @@ export class BlockDeleteTextContentStrategy extends BlockDeleteNodeContentStrate
     else {
       let previousNode = this.getPreviousNode(startContainerNode);
       let nextNode = null;
-      if (target.nodes.length && previousNode && previousNode.parentBlock !== target) {
+      if (target.children.length && previousNode && previousNode.parent !== target) {
         if (startContainerNode.isEmpty()) {
           target.apply(new RemoveChildAction(startContainerNode));
         }
-        if (target.type === previousNode.parentBlock.type) {
-          previousNode.parentBlock.apply(new MergeTwoBlocksNodesAction(target));
+        if (target.type === previousNode.parent.type) {
+          previousNode.parent.apply(new MergeTwoBlocksNodesAction(target));
         }
       }
       else {
@@ -80,14 +80,14 @@ export class BlockDeleteTextContentStrategy extends BlockDeleteNodeContentStrate
         if (previousNode instanceof RTETextNode && previousNode.isEmpty()) {
           const shouldRemoveNode = previousNode;
           previousNode = this.getPreviousNode(previousNode);
-          shouldRemoveNode.parentBlock.apply(new RemoveChildAction(shouldRemoveNode));
+          shouldRemoveNode.parent.apply(new RemoveChildAction(shouldRemoveNode));
           if (!previousNode) {
             nextNode = startContainerNode;
           }
         }
       }
       //Remove the paragraph block if the content is empty
-      if (target.nodes.length === 0) {
+      if (target.children.length === 0) {
         target.parent.apply(new RemoveChildAction(target));
       }
       if (previousNode) {

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

@@ -20,12 +20,12 @@ export class BlockInsertBlocksBeforeStrategy extends ActionHandleStrategy {
    * @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) {
+    if (target.children) {
       blocks.forEach((block) => {
         block.parent = target;
       });
-      const arrayFixed = target.blocks;
-      target.blocks = arrayFixed.flatMap((block) => {
+      const arrayFixed = target.children;
+      target.children = arrayFixed.flatMap((block) => {
         if (block === referBlock) {
           return blocks;
         }

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

@@ -25,10 +25,10 @@ export class BlockInsertLineBreakStrategy extends ActionHandleStrategy {
       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);
+      const nodesSplitIndex = target.children.indexOf(splitNode);
       if (nodesSplitIndex > -1) {
-        const beforeNodes = target.nodes.slice(0, nodesSplitIndex);
-        const afterNodes = target.nodes.slice(nodesSplitIndex + 1);
+        const beforeNodes = target.children.slice(0, nodesSplitIndex);
+        const afterNodes = target.children.slice(nodesSplitIndex + 1);
         if (beforeText) {
           beforeNodes.push(splitNode.cloneWithText(beforeText));
         }

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

@@ -21,7 +21,7 @@ export class BlockInsertLineBreakWithBlocksStrategy extends ActionHandleStrategy
    * @returns {Nullable<RTETextNode>} Nullable<RTETextNode>
    */
   lineBreakMultipleBlocks(selectedBlocks, target) {
-    const beforeNodes = target.nodes;
+    const beforeNodes = target.children;
     const lineBreakNode = new RTETextNode(generateUUID(), '\n', target);
     const afterNodes = this.concatBlocksNodes(selectedBlocks.slice(1));
     this.mergeLineBreakNodes(beforeNodes, lineBreakNode, afterNodes, target);
@@ -37,7 +37,7 @@ export class BlockInsertLineBreakWithBlocksStrategy extends ActionHandleStrategy
     const nodes = [];
     blocks.map((block) => {
       if (block.type !== 'image') {
-        nodes.push(...block['nodes']);
+        nodes.push(...block.children);
         block.parent.apply(new RemoveChildAction(block));
       }
     });

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

@@ -14,9 +14,9 @@ export class BlockMergeNodesStrategy extends ActionHandleStrategy {
   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);
+      let shouldMergeNodes = anotherBlock.children;
+      if (anotherBlock.type !== 'image') {
+        shouldMergeNodes = anotherBlock.children.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

@@ -8,8 +8,8 @@ export class BlockRemoveChildBlockStrategy extends ActionHandleStrategy {
    */
   handleAction(action, target) {
     const blockToBeRemoved = action.entityToBeRemoved;
-    if (target.blocks) {
-      target.blocks = target.blocks.filter((block) => block !== blockToBeRemoved);
+    if (target.children) {
+      target.children = target.children.filter((block) => block !== blockToBeRemoved);
     }
   }
 }

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

@@ -12,9 +12,9 @@ export class BlockRemoveNodeStrategy extends ActionHandleStrategy {
    * @param {RTEBlockWithNodes} 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) {
+    const arrayFixed = target.children;
+    target.children = arrayFixed.filter((node) => node !== action.entityToBeRemoved);
+    if (target.children.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

@@ -11,11 +11,11 @@ export class BlockReplaceNodeWithNodesStrategy extends ActionHandleStrategy {
    * @param {RTENode[]} newNodes - The array of the text node or the image node.
    */
   replaceNodeWithNodes(target, referNode, newNodes) {
-    if (target['nodes']) {
+    if (target.children) {
       newNodes.forEach((node) => {
-        node.parentBlock = target;
+        node.parent = target;
       });
-      target['nodes'] = target['nodes'].flatMap((node) => {
+      target.children = target.children.flatMap((node) => {
         if (node === referNode) {
           return newNodes;
         }

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

@@ -11,7 +11,7 @@ export class BlockReplaceNodesStrategy extends ActionHandleStrategy {
    * @param {RTETextBlock | RTEImageBlock} target - The text block or the image block.
    */
   handleAction(action, target) {
-    target.nodes = [];
+    target.children = [];
     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

@@ -22,10 +22,10 @@ export class BlockSplitWithImageNodeStrategy extends ActionHandleStrategy {
    * @returns {Nullable<RTEBlock>} The new block after split
    */
   splitImageNodes(imageNode, imageOffset, target) {
-    const nodesSplitIndex = target.nodes.indexOf(imageNode);
+    const nodesSplitIndex = target.children.indexOf(imageNode);
     if (nodesSplitIndex > -1) {
-      const beforeNodes = target.nodes.slice(0, nodesSplitIndex + imageOffset);
-      const afterNodes = target.nodes.slice(nodesSplitIndex + imageOffset);
+      const beforeNodes = target.children.slice(0, nodesSplitIndex + imageOffset);
+      const afterNodes = target.children.slice(nodesSplitIndex + imageOffset);
       target.apply(new ReplaceChildNodesAction(beforeNodes));
       const newBlock = this.cloneWithNodes(afterNodes, target);
       target.parent.apply(new InsertBlocksAfterAction(target, newBlock));
@@ -41,7 +41,7 @@ export class BlockSplitWithImageNodeStrategy extends ActionHandleStrategy {
    */
   cloneWithNodes(nodes, target) {
     const block = target.createNewImageBlock();
-    block.nodes = [];
+    block.children = [];
     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

@@ -23,10 +23,10 @@ export class BlockSplitWithTextNodeStrategy extends ActionHandleStrategy {
     if (splitNode) {
       const beforeText = splitNode.text.slice(0, startOffsetOfNode);
       const afterText = splitNode.text.slice(startOffsetOfNode);
-      const nodesSplitIndex = textBlock.nodes.indexOf(splitNode);
+      const nodesSplitIndex = textBlock.children.indexOf(splitNode);
       if (nodesSplitIndex > -1) {
-        const beforeNodes = textBlock.nodes.slice(0, nodesSplitIndex);
-        const afterNodes = textBlock.nodes.slice(nodesSplitIndex + 1);
+        const beforeNodes = textBlock.children.slice(0, nodesSplitIndex);
+        const afterNodes = textBlock.children.slice(nodesSplitIndex + 1);
         if (beforeText) {
           beforeNodes.push(splitNode.cloneWithText(beforeText));
         }

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

@@ -30,7 +30,7 @@ export class BlockTransformToCodeBlockStrategy extends ActionHandleStrategy {
     const selectedTextBlocks = selectedBlocks.filter((item) => item.type !== 'image' && item.type !== 'list-item');
     return selectedTextBlocks
       .map((block) => {
-      return block.nodes.map((node) => node.text).join('');
+      return block.children.map((node) => node.text).join('');
     })
       .join('\n');
   }

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

@@ -15,7 +15,7 @@ export class CodeBlockRemoveSelfStrategy extends BlockDeleteNodeContentStrategy
    * @inheritDoc
    */
   handleAction(_action, target) {
-    const node = target.nodes[0];
+    const node = target.children[0];
     const parent = target.parent;
     if (parent) {
       let focusNode = this.getPreviousNode(node);
@@ -28,14 +28,14 @@ export class CodeBlockRemoveSelfStrategy extends BlockDeleteNodeContentStrategy
       const focusElement = focusNode
         ? stateEntityRenderingRegistry.getDOMByEntity(focusNode)
         : null;
-      if (parent.blocks.length === 0) {
+      if (parent.children.length === 0) {
         const defaultParagraph = RTETextBlock.from({
           id: generateUUID(),
           type: 'paragraph',
           nodes: [{ id: generateUUID(), type: 'text', text: '' }],
         });
         target.parent.apply(new AppendChildNodesAction([defaultParagraph]));
-        focusNode = defaultParagraph.nodes[0];
+        focusNode = defaultParagraph.children[0];
         offset = 0;
       }
       this.notifyUpdateSelection(focusNode, focusElement, offset, target);

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

@@ -14,8 +14,8 @@ export class ImageBlockInsertImageStrategy extends ActionHandleStrategy {
     const splitNode = action.splitPointNode;
     const startOffsetOfNode = action.startOffsetOfNode;
     const newImageBlock = action.imageBlockToBeInserted;
-    const newImageNodes = newImageBlock.nodes;
-    if (target.nodes.length < 1) {
+    const newImageNodes = newImageBlock.children;
+    if (target.children.length < 1) {
       target.apply(new AppendChildNodesAction(newImageNodes));
     }
     else if (this.isCaretPositionAtImageBlockEnd(target, splitNode, startOffsetOfNode)) {

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

@@ -15,7 +15,7 @@ export class ImageInsertLineBreakStrategy extends ActionHandleStrategy {
     target.apply(insertNewParagraphAction);
     const newBlock = insertNewParagraphAction.newBlock;
     if (newBlock) {
-      action.lineBreakNode = newBlock.nodes[0];
+      action.lineBreakNode = newBlock.children[0];
     }
   }
 }

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

@@ -34,7 +34,7 @@ export class ImageInsertLineBreakWithBlocksStrategy extends ActionHandleStrategy
       afterNodes.push(new RTETextNode(generateUUID(), '\n', newParagraph));
     }
     newParagraph.apply(new AppendChildNodesAction(afterNodes));
-    return newParagraph['nodes'][0];
+    return newParagraph['children'][0];
   }
   /**
    * Concat the child nodes of multiple RTEBlocks if both are not images.
@@ -46,7 +46,7 @@ export class ImageInsertLineBreakWithBlocksStrategy extends ActionHandleStrategy
     const nodes = [];
     blocks.map((block) => {
       if (block.type !== 'image') {
-        nodes.push(...block['nodes']);
+        nodes.push(...block.children);
         block.parent.apply(new RemoveChildAction(block));
       }
     });

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

@@ -13,7 +13,7 @@ export class ListItemDeleteTextContentStrategy extends BlockDeleteTextContentStr
   handleAction(action, target) {
     const listBlock = target.parent;
     this.deleteNodeContent(action, target);
-    if (listBlock.blocks.length === 0) {
+    if (listBlock.children.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-new-paragraph-strategy.js

@@ -52,8 +52,8 @@ export class ListItemInsertNewParagraphStrategy extends ActionHandleStrategy {
    * @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();
+    const lastItem = target.parent.children[target.parent.children.length - 1];
+    const currentItemIsEmpty = target.children.length === 1 && target.children[0].isEmpty();
     if (target === lastItem && currentItemIsEmpty) {
       const parentParent = target.parent.parent;
       if (parentParent['type'] !== 'list-item') {
@@ -62,7 +62,7 @@ export class ListItemInsertNewParagraphStrategy extends ActionHandleStrategy {
           type: 'paragraph',
           nodes: [],
         });
-        newParagraph.apply(new AppendChildNodesAction(newListItem.nodes));
+        newParagraph.apply(new AppendChildNodesAction(newListItem.children));
         parentParent.apply(new InsertBlocksAfterAction(target.parent, newParagraph));
         target.parent.apply(new RemoveChildAction(target));
         return newParagraph;

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

@@ -10,12 +10,12 @@ export class ListItemRemoveNestListStrategy extends ActionHandleStrategy {
    * @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);
+    if (target.nestList) {
+      if (target.nestList.length > 1) {
+        target.nestList = target.nestList.filter((child) => child !== action.nestListBlockToBeRemoved);
       }
       else {
-        target.children = undefined;
+        target.nestList = undefined;
       }
     }
   }

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

@@ -11,8 +11,8 @@ export class ListItemRemoveNodeStrategy extends ActionHandleStrategy {
    * @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.children = target.children.filter((node) => node !== action.entityToBeRemoved);
+    if (target.children.length === 0 && (!target.nestList || !target.nestList.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

@@ -10,6 +10,6 @@ export class ListItemReplaceNestListStrategy extends ActionHandleStrategy {
     action.newList.forEach((listBlock) => {
       listBlock.parent = target;
     });
-    target.children = action.newList;
+    target.nestList = action.newList;
   }
 }

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

@@ -14,7 +14,7 @@ export class ListRemoveListItemStrategy extends BlockRemoveChildBlockStrategy {
   handleAction(action, target) {
     super.handleAction(action, target);
     const parent = target.parent;
-    if (target.blocks.length === 0 && parent) {
+    if (target.children.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));

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

@@ -16,10 +16,10 @@ 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.blocks));
+      bulletList.apply(new AppendChildNodesAction(target.children));
       target.parent.apply(new InsertBlocksAfterAction(target, bulletList));
       target.parent.apply(new RemoveChildAction(target));
-      selectedBlocks.forEach((block) => block.nodes.map((node) => node.apply(new SyncUpSelectionAction())));
+      selectedBlocks.forEach((block) => block.children.map((node) => node.apply(new SyncUpSelectionAction())));
     }
     else {
       const listItems = action.selectedBlocks.map((block) => target.parent.toListItem(block));
@@ -28,7 +28,7 @@ export class ListTransformToListStrategy extends ActionHandleStrategy {
       action.selectedBlocks.forEach((block) => {
         block.parent.apply(new RemoveChildAction(block));
       });
-      if (target.blocks.length === 0) {
+      if (target.children.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

@@ -18,10 +18,10 @@ export class ListTransformToParagraphStrategy extends ActionHandleStrategy {
     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])
+      block.children.map((node) => node.apply(new SyncUpSelectionAction()));
+      if (block === target.children[0])
         isSelectedFirstBlock = true;
-      if (block === target.blocks[target.blocks.length - 1])
+      if (block === target.children[target.children.length - 1])
         isSelectedLastBlock = true;
       return this.toParagraph(block);
     });
@@ -32,19 +32,19 @@ export class ListTransformToParagraphStrategy extends ActionHandleStrategy {
       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 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.blocks.slice(0, startIndex)));
+      firstBulletList.apply(new AppendChildNodesAction(target.children.slice(0, startIndex)));
       const lastBulletList = target.parent.createList(target.type);
-      lastBulletList.apply(new AppendChildNodesAction(target.blocks.slice(lastIndex + 1)));
+      lastBulletList.apply(new AppendChildNodesAction(target.children.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) {
+    if (target.children.length === 0) {
       target.parent.apply(new RemoveChildAction(target));
     }
   }
@@ -56,7 +56,7 @@ export class ListTransformToParagraphStrategy extends ActionHandleStrategy {
    */
   toParagraph(block) {
     const textBlock = new RTETextBlock(generateUUID(), 'paragraph');
-    textBlock.apply(new AppendChildNodesAction(block['nodes']));
+    textBlock.apply(new AppendChildNodesAction(block['children']));
     textBlock['annotationMap'] = block['annotationMap'];
     return textBlock;
   }

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

@@ -19,7 +19,7 @@ export class SwitchOutFromCodeBlockStrategy extends ActionHandleStrategy {
     const textArray = content.split('\n');
     const updateAction = new UpdateCodeBlockAction(textArray.slice(0, textArray.length - 2).join('\n'), language);
     updateAction.isFlushable = false;
-    target.nodes[0].apply(updateAction);
+    target.children[0].apply(updateAction);
     const textBlock = RTETextBlock.from({
       id: generateUUID(),
       type: 'paragraph',
@@ -31,7 +31,7 @@ export class SwitchOutFromCodeBlockStrategy extends ActionHandleStrategy {
     if (currentNodeDom) {
       const nodeSubject = domNodeSubjectFactory.getSubjectFromParentNodeByEventId(currentNodeDom, VegaInternalRichTextEditorSelectionRangeChange);
       if (nodeSubject) {
-        changeManager.notify(nodeSubject, { node: textBlock.nodes[0] });
+        changeManager.notify(nodeSubject, { node: textBlock.children[0] });
       }
     }
   }

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

@@ -75,6 +75,14 @@ export class RTEBlock {
       }
     }
   }
+  /**
+   * Check if the block is a list item block
+   *
+   * @returns {boolean} True if the block is a list item block, false otherwise.
+   */
+  isListItemBlock() {
+    return this.type === 'list-item';
+  }
   /**
    * Apply action to block
    *