@heartlandone/vega 2.34.0 → 2.35.0-RTE-preview

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

@@ -1,12 +1,4 @@
-import { h } from '@stencil/core';
 import { Annotation, InternalAnnotationTypeEnum } from './annotation.abstract';
-import { generateUUID } from '../../../../utils/misc';
-import { LinkAnnotationAction } from '../actions/link-annotation-action';
-import { NodeAnnotationTypeEnum } from './node-annotation.abstract';
-import { DomNodeSubjectObserverFactory } from '../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-observer-factory';
-import { VegaChange } from '../../../../helpers/event-manager/event-id/vega-event-id';
-import { isNonNullable } from '../../../../types/type-guard';
-import { createEnterKeyHandlerToTriggerClick } from '../../../../utils/accessibility';
 /**
  * Annotation to represent a link of grouped nodes
  */
@@ -17,86 +9,4 @@ export class LinkGroupAnnotation extends Annotation {
     this.linkGroups = new Map();
     this.linkGroups = new Map([[groupKey, []]]);
   }
-  renderNodes(nodes, { editable }) {
-    const blockNodes = this.groupNodesByLink(nodes);
-    return blockNodes.flatMap((item) => {
-      if (this.isLinkGroup(item)) {
-        const linkAnnotation = item[0].getAnnotationByType(NodeAnnotationTypeEnum.LINK);
-        return editable
-          ? this.renderLinkEditorWrapper(item, linkAnnotation)
-          : this.renderLink(item, linkAnnotation);
-      }
-      return item.render();
-    });
-  }
-  renderLinkEditorWrapper(linkNodes, linkAnnotation) {
-    const { href } = linkAnnotation.link;
-    const textFromNodes = linkNodes.map((node) => node.text).join('');
-    const handleChange = ({ detail, }) => {
-      switch (detail.action) {
-        case 'link': {
-          const { url, text } = detail.payload;
-          const textChanged = text !== textFromNodes;
-          const groupKey = generateUUID();
-          linkNodes.forEach((node) => {
-            const linkAnnotationAction = new LinkAnnotationAction({
-              link: { href: url, groupKey: groupKey },
-              newText: textChanged ? text : undefined,
-              needMergeNode: textChanged && linkNodes.length > 1,
-              doSplit: false,
-            });
-            node.apply(linkAnnotationAction);
-          });
-          return;
-        }
-        case 'unlink': {
-          linkNodes.forEach((node) => node.deleteAnnotationByType(NodeAnnotationTypeEnum.LINK));
-          return;
-        }
-      }
-    };
-    let linkWrapperRef;
-    return (h("span", { class: "link-editor-wrapper", role: "link", tabIndex: 0, onKeyDown: createEnterKeyHandlerToTriggerClick(), ref: (ref) => {
-        if (ref) {
-          linkWrapperRef = ref;
-        }
-      } },
-      this.renderLink(linkNodes, linkAnnotation),
-      h("vega-rich-text-link-editor", { record: {
-          text: textFromNodes,
-          url: href,
-        }, ref: (ref) => {
-          if (ref) {
-            ref.target = linkWrapperRef;
-            DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaChange, handleChange);
-          }
-        } })));
-  }
-  renderLink(linkNodes, linkAnnotation) {
-    const { href } = linkAnnotation.link;
-    return (h("a", { class: "v-rte--link", href: href, target: "_blank" }, linkNodes.map((node) => node.render())));
-  }
-  isLinkGroup(item) {
-    return Array.isArray(item);
-  }
-  groupNodesByLink(nodes) {
-    return nodes.reduce((acc, node) => {
-      const nodeLinkAnnotation = node.getAnnotationByType(NodeAnnotationTypeEnum.LINK);
-      const lastGroup = acc[acc.length - 1];
-      if (isNonNullable(nodeLinkAnnotation)) {
-        if (lastGroup &&
-          this.isLinkGroup(lastGroup) &&
-          lastGroup[0].getAnnotationByType(NodeAnnotationTypeEnum.LINK).toEqual(nodeLinkAnnotation)) {
-          lastGroup.push(node);
-        }
-        else {
-          acc.push([node]);
-        }
-      }
-      else {
-        acc.push(node);
-      }
-      return acc;
-    }, []);
-  }
 }

package/dist/collection/components/vega-rich-text-editor/dto/annotations/strikethrough-annotation.js

@@ -17,17 +17,6 @@ export class StrikethroughAnnotation extends NodeAnnotation {
   static from(strikethrough) {
     return [NodeAnnotationTypeEnum.STRIKETHROUGH, new StrikethroughAnnotation(strikethrough)];
   }
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[NodeAnnotationTypeEnum.STRIKETHROUGH, StrikethroughAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node) {
-    return this.from(node.style.textDecoration.includes('line-through') ||
-      node.nodeName === 'S' ||
-      node.classList.contains('v-rte--strikethrough'));
-  }
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/collection/components/vega-rich-text-editor/dto/annotations/text-color-annotation.js

@@ -1,6 +1,5 @@
 import { NodeAnnotation, NodeAnnotationTypeEnum } from './node-annotation.abstract';
 import { RTE_TEXT_COLORS } from '../../constants/constant';
-import { rgbToHex } from '../../../../utils/ui';
 import { VegaThemeManager } from '../../../../helpers/theme/theme-manager';
 /**
  * Annotation to make text with text color
@@ -20,31 +19,6 @@ export class TextColorAnnotation extends NodeAnnotation {
   static from(textColor) {
     return [NodeAnnotationTypeEnum.TEXT_COLOR, new TextColorAnnotation(textColor)];
   }
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[NodeAnnotationTypeEnum.TEXT_COLOR, TextColorAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node) {
-    var _a;
-    const color = node.style.color;
-    const hexColor = (_a = rgbToHex(color)) === null || _a === void 0 ? void 0 : _a.toUpperCase();
-    if (hexColor) {
-      const colorSchema = RTE_TEXT_COLORS.find((schema) => schema.light === hexColor || schema.dark === hexColor);
-      if (colorSchema)
-        return this.from(colorSchema.key);
-      return null;
-    }
-    else {
-      for (const color of RTE_TEXT_COLORS) {
-        if (node.style.color.includes(color.key)) {
-          return this.from(color.key);
-        }
-      }
-      return null;
-    }
-  }
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/collection/components/vega-rich-text-editor/dto/annotations/text-style-annotation.js

@@ -17,50 +17,6 @@ export class TextStyleAnnotation extends BlockAnnotation {
   static from(textStyle) {
     return [BlockAnnotationTypeEnum.TEXT_STYLE, new TextStyleAnnotation(textStyle)];
   }
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[BlockAnnotationTypeEnum.TEXT_STYLE, TextStyleAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node) {
-    return this.from(this.getTextStyle(node));
-  }
-  /**
-   * Get the type of block.
-   *
-   * @param {HTMLElement} node - An HTMLElement.
-   * @returns {VegaRTETextStyleType} text style type.
-   */
-  static getTextStyle(node) {
-    if (node.nodeType !== Node.TEXT_NODE && node.hasAttribute('data-type')) {
-      return node.getAttribute('data-type');
-    }
-    switch (node.style.fontSize) {
-      case '36px':
-        return 'title';
-      case '28px':
-        return 'subtitle';
-      case '22px':
-        return 'heading-1';
-      case '20px':
-        return 'heading-2';
-      case '18px':
-        return 'heading-3';
-      default:
-        break;
-    }
-    switch (node.nodeName) {
-      case 'H1':
-        return 'heading-1';
-      case 'H2':
-        return 'heading-2';
-      case 'H3':
-        return 'heading-3';
-      default:
-        return 'paragraph';
-    }
-  }
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/collection/components/vega-rich-text-editor/dto/annotations/underline-annotation.js

@@ -17,17 +17,6 @@ export class UnderlineAnnotation extends NodeAnnotation {
   static from(underline) {
     return [NodeAnnotationTypeEnum.UNDERLINE, new UnderlineAnnotation(underline)];
   }
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[NodeAnnotationTypeEnum.UNDERLINE, UnderlineAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node) {
-    return this.from(node.style.textDecoration.includes('underline') ||
-      node.nodeName === 'U' ||
-      node.classList.contains('v-rte--underline'));
-  }
   /**
    * Generate the JSON representation of the annotation
    *

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

@@ -3,7 +3,6 @@ import ChangeManager from '../../../../helpers/change-manager/change-manager';
 import domNodeSubjectFactory from '../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-factory';
 import stateEntityRenderingRegistry from '../../slimmers/controllers/state-entity-rendering-registry';
 import { VegaInternalRichTextEditorFlushChanges } from '../../../../helpers/event-manager/event-id/vega-internal-event-id';
-import { isNonNullable } from '../../../../types/type-guard';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 import { HorizontalAlignmentAnnotation } from '../annotations/horizontal-alignment-annotation';
 import { IndentAnnotation } from '../annotations/indent-annotation';
@@ -11,7 +10,6 @@ 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 { TextStyleAnnotation } from '../annotations/text-style-annotation';
 /**
  * Abstract class for block
  */
@@ -41,23 +39,6 @@ export class RTEBlock extends BlockBaseOperator {
         return IndentAnnotation.from(value);
     }
   }
-  /**
-   * Create annotations for block element.
-   *
-   * @param {string} type - Annotations type.
-   * @param {HTMLElement} node - current node.
-   * @returns {Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>} - result.
-   */
-  static createAnnotationEntityFromHTML(type, node) {
-    switch (type) {
-      case 'ALIGNMENT':
-        return HorizontalAlignmentAnnotation.fromHTML(node);
-      case 'TEXT_STYLE':
-        return TextStyleAnnotation.fromHTML(node);
-      case 'INDENT':
-        return IndentAnnotation.fromHTML(node);
-    }
-  }
   /**
    * Class to JSON object
    *
@@ -120,29 +101,6 @@ export class RTEBlock extends BlockBaseOperator {
     this.annotationMap.set(annotation.type, annotation);
     typeof this.doAnnotationActionApply === 'function' && this.doAnnotationActionApply(action);
   }
-  /**
-   * Get styles from annotations
-   *
-   * @returns {AnnotationStyle} - Annotation style
-   */
-  getStyles() {
-    return Array.from(this.annotationMap.values())
-      .filter((annotation) => annotation instanceof BlockAnnotation)
-      .map((annotation) => annotation.render())
-      .filter(isNonNullable)
-      .reduce((current, obj) => (Object.assign(Object.assign({}, current), obj)), {});
-  }
-  /**
-   * Get classes from annotations
-   *
-   * @returns {AnnotationStyle} - Annotation style
-   */
-  getClasses() {
-    return Array.from(this.annotationMap.values())
-      .map((annotation) => { var _a; return (_a = annotation.renderClass) === null || _a === void 0 ? void 0 : _a.call(annotation); })
-      .filter(isNonNullable)
-      .reduce((pre, cur) => [pre, cur].join(' '), '');
-  }
   /**
    * 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.
    *

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

@@ -1,10 +1,7 @@
-import { h } from '@stencil/core';
 import { RTEBlock } from './block.abstract';
 import { RTEImageNode } from '../nodes/image-node';
-import stateEntityRenderingRegistry from '../../slimmers/controllers/state-entity-rendering-registry';
 import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
 import { RemoveChildAction } from '../actions/remove-child-action';
-import { BlockAnnotationTypeEnum } from '../annotations/block-annotation.abstract';
 import { isNonNullable } from '../../../../types/type-guard';
 import { AppendChildNodesAction } from '../actions/append-child-nodes-action';
 import { ReplaceChildNodesAction } from '../actions/replace-child-nodes-action';
@@ -23,6 +20,12 @@ export class RTEImageBlock extends RTEBlock {
     this.type = 'image';
     this.nodes = [];
   }
+  /**
+   * Converts a VegaRTEImageBlock object into an RTEImageBlock object by mapping nodes and creating annotations.
+   *
+   * @param {VegaRTEImageBlock} block - The block object to be converted.
+   * @returns {RTEImageBlock} An instance of `RTEImageBlock`
+   */
   static from(block) {
     const imageBlock = new RTEImageBlock(block.id);
     const { annotations } = block;
@@ -37,34 +40,26 @@ export class RTEImageBlock extends RTEBlock {
     }
     return imageBlock;
   }
-  static fromHTML(node) {
-    const nodes = node.nodeName === 'IMG' ? [node] : Array.from(node.children);
-    const imageBlock = new RTEImageBlock(generateUUID());
-    imageBlock.nodes = nodes.map((item) => RTEImageNode.fromHTML(item, imageBlock));
-    Object.keys(BlockAnnotationTypeEnum).forEach((type) => {
-      const item = this.createAnnotationEntityFromHTML(type, node);
-      if (isNonNullable(item)) {
-        imageBlock.annotationMap.set(...item);
-      }
-    });
-    return imageBlock;
-  }
+  /**
+   * @inheritDoc
+   */
   toJSON() {
     return Object.assign(Object.assign({}, super.toJSON()), { type: 'image', nodes: this.nodes.map((node) => node.toJSON()) });
   }
+  /**
+   * @inheritDoc
+   */
   isNotEmpty() {
     return this.nodes.length > 0 && this.nodes.some((node) => node.url.length > 0);
   }
+  /**
+   * @inheritDoc
+   */
   getLastNode() {
     return this.nodes[this.nodes.length - 1];
   }
-  render(renderContext) {
-    return (h("div", { style: Object.assign({}, this.getStyles()), ref: this.registerRef.bind(this), class: super.getClasses() }, this.nodes.map((node) => {
-      return node.render(renderContext);
-    })));
-  }
   /**
-   * Apply modify action to block
+   * Apply a modify action to block
    *
    * @param {ModifyContentAction} action - Modify action
    */
@@ -118,11 +113,11 @@ export class RTEImageBlock extends RTEBlock {
         break;
     }
   }
-  registerRef(ref) {
-    if (ref) {
-      stateEntityRenderingRegistry.register(ref, this);
-    }
-  }
+  /**
+   * Removes a specified child node from a list of nodes and triggers a parent action if the list becomes empty.
+   *
+   * @param {RemoveChildAction} action - Action to be performed when removing a child node from the list of nodes.
+   */
   removeChildNode(action) {
     this.nodes = this.nodes.filter((node) => node !== action.entityToBeRemoved);
     if (this.nodes.length === 0) {
@@ -135,6 +130,7 @@ export class RTEImageBlock extends RTEBlock {
    *
    * @param {RTEImageNode} imageNode The split point image node
    * @param {number} imageOffset The cursor point 0 | 1
+   * @returns {Nullable<RTEBlock>} The new block after split
    */
   splitImageNodes(imageNode, imageOffset) {
     const nodesSplitIndex = this.nodes.indexOf(imageNode);
@@ -147,12 +143,25 @@ export class RTEImageBlock extends RTEBlock {
       return newBlock;
     }
   }
+  /**
+   * Creates a new RTEImageBlock instance with the provided RTEImageNode instances appended to it.
+   *
+   * @param {RTEImageNode[]} nodes - An array of RTEImageNode objects that will be used to create a new RTEImageBlock instance.
+   * @returns {RTEImageBlock} A new `RTEImageBlock` object with the provided `nodes` appended to it.
+   */
   cloneWithNodes(nodes) {
     const block = new RTEImageBlock(generateUUID());
     block.nodes = [];
     block.apply(new AppendChildNodesAction(nodes));
     return block;
   }
+  /**
+   * Used to split a block of text at a specific position and insert a new paragraph block.
+   *
+   * @param {RTEImageNode} splitNode - The node that needs to be split into separate blocks.
+   * @param {number} startOffsetOfNode - The index or position within the `splitNode` where the block should be broken or split.
+   * @returns {Nullable<RTEBlock>} Returns either a new paragraph block or the new block created after splitting the original block.
+   */
   breakSingleBlock(splitNode, startOffsetOfNode) {
     const newParagraph = RTETextBlock.from({
       id: generateUUID(),
@@ -172,19 +181,46 @@ export class RTEImageBlock extends RTEBlock {
     }
     return newParagraph;
   }
+  /**
+   * Breaks a single block of text at a specified offset and returns the first node of the new paragraph if created.
+   *
+   * @param {RTEImageNode} splitNode - It represents a node in a rich text editor that contains an image.
+   * @param {number} startOffset - The index at which the line break should occur within the `RTEImageNode` block.
+   * @returns {Nullable<RTETextNode>} Returning the first node of the `newParagraph` block if `newParagraph` is not null.
+   */
   lineBreakSingleBlock(splitNode, startOffset) {
     const newParagraph = this.breakSingleBlock(splitNode, startOffset);
     if (newParagraph) {
       return newParagraph['nodes'][0];
     }
   }
+  /**
+   * Checks if the caret position is at the start of a specified RTEImageNode.
+   *
+   * @param {RTEImageNode} node - `RTEImageNode` - a node representing an image in a rich text editor.
+   * @param {number} startOffset - The position within the text node where the caret is located.
+   * @returns {boolean} a boolean value, which indicates whether the caret position is at the start of the RTEImageNode.
+   */
   isCaretPositionAtStart(node, startOffset) {
     return node === this.nodes[0] && startOffset === 0;
   }
+  /**
+   * Checks if the caret position is at the end of a given RTEImageNode.
+   *
+   * @param {RTEImageNode} node - `node` is a RTEImageNode
+   * @param {number} startOffset - The position within the `RTEImageNode` where the caret is located.
+   * @returns {boolean}Returns a boolean value indicating whether the caret position is at the end of the `RTEImageNode`.
+   */
   isCaretPositionAtEnd(node, startOffset) {
     const lastNode = this.nodes[this.nodes.length - 1];
     return node === lastNode && startOffset === 1;
   }
+  /**
+   * Inserts a new paragraph block with a line break after a selected block of text in a rich text editor.
+   *
+   * @param {RTEBlock[]} selectedBlocks - An array of RTEBlock objects that represent the blocks that have been selected for a specific action in the Rich Text Editor.
+   * @returns {Nullable<RTETextNode>} Returns a Nullable RTETextNode.
+   */
   lineBreakMultipleBlocks(selectedBlocks) {
     const newParagraph = RTETextBlock.from({
       id: generateUUID(),
@@ -199,6 +235,11 @@ export class RTEImageBlock extends RTEBlock {
     newParagraph.apply(new AppendChildNodesAction(afterNodes));
     return newParagraph['nodes'][0];
   }
+  /**
+   * Deletes content from a block node based on specific conditions.
+   *
+   * @param {DeleteBlockContentAction} action - Delete block content action
+   */
   deleteNodeContent(action) {
     const startContainerNode = action
       .startContainerNode, startOffset = action.startOffset;

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

@@ -1,7 +1,5 @@
-import { h } from '@stencil/core';
 import { RTEBlock } from './block.abstract';
 import { RTEListItemBlock } from './list-item-block';
-import stateEntityRenderingRegistry from '../../slimmers/controllers/state-entity-rendering-registry';
 import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
 import { RemoveChildAction } from '../actions/remove-child-action';
 import { InsertBlocksAfterAction } from '../actions/insert-blocks-after-block';
@@ -11,8 +9,9 @@ import { AppendChildNodesAction } from '../actions/append-child-nodes-action';
 import { InsertBlocksBeforeAction } from '../actions/insert-blocks-before-block';
 import { SyncUpSelectionAction } from '../actions/sync-up-selection-action';
 import { RemoveNestListAction } from '../actions/remove-nest-list-action';
-import { BlockAnnotationTypeEnum } from '../annotations/block-annotation.abstract';
-import { isNonNullable } from '../../../../types/type-guard';
+/**
+ * List block
+ */
 export class RTEListBlock extends RTEBlock {
   constructor(id, type) {
     super(id);
@@ -20,6 +19,12 @@ export class RTEListBlock extends RTEBlock {
     this.blocks = [];
     this.type = type;
   }
+  /**
+   * Converts a VegaRTEListBlock object to an RTEListBlock
+   *
+   * @param {VegaRTEListBlock} block - Converts a `VegaRTEListBlock` object into an `RTEListBlock`.
+   * @returns {RTEListBlock} Return an instance of `RTEListBlock`
+   */
   static from(block) {
     const listBlock = new RTEListBlock(block.id, block.type);
     listBlock.blocks = block.blocks.map((item) => {
@@ -29,37 +34,25 @@ export class RTEListBlock extends RTEBlock {
     });
     return listBlock;
   }
-  static fromHTML(node) {
-    const listBlock = new RTEListBlock(generateUUID(), node.nodeName === 'UL' ? 'bullet-list' : 'number-list');
-    listBlock.blocks = Array.from(node.children)
-      .map((item) => {
-      const listItemBlock = RTEListItemBlock.fromHTML(item);
-      listItemBlock && (listItemBlock.parent = listBlock);
-      return listItemBlock;
-    })
-      .filter(Boolean);
-    Object.keys(BlockAnnotationTypeEnum).forEach((type) => {
-      const item = this.createAnnotationEntityFromHTML(type, node);
-      if (isNonNullable(item)) {
-        listBlock.annotationMap.set(...item);
-      }
-    });
-    return listBlock;
-  }
+  /**
+   * @inheritDoc
+   */
   toJSON() {
     return Object.assign(Object.assign({}, super.toJSON()), { id: this.id, type: this.type, blocks: this.blocks.map((block) => block.toJSON()) });
   }
+  /**
+   * @inheritDoc
+   */
   isNotEmpty() {
     return (this.blocks.length > 0 &&
       this.blocks.some((listItemBlock) => listItemBlock.isNotEmpty()));
   }
+  /**
+   * @inheritDoc
+   */
   getLastNode() {
     return this.blocks[this.blocks.length - 1].getLastNode();
   }
-  render(renderContext) {
-    const BlockTag = this.type === 'number-list' ? 'ol' : 'ul';
-    return (h(BlockTag, { ref: this.registerRef.bind(this) }, this.blocks.map((block) => block.render(renderContext))));
-  }
   /**
    * Apply a modify action to block
    *
@@ -96,17 +89,23 @@ export class RTEListBlock extends RTEBlock {
         break;
     }
   }
+  /**
+   * 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;
   }
-  registerRef(ref) {
-    if (ref) {
-      stateEntityRenderingRegistry.register(ref, this);
-    }
-  }
+  /**
+   * Covert block to List
+   *
+   * @param {TransformListAction} action - Modify action
+   */
   convertToList(action) {
     const selectedBlocks = action.selectedBlocks;
     const bulletList = this.parent.createList(action.listType);
@@ -130,6 +129,11 @@ export class RTEListBlock extends RTEBlock {
       }
     }
   }
+  /**
+   * Covert block to paragraph
+   *
+   * @param {TransformListAction} action - Modify action
+   */
   convertToParagraph(action) {
     let isSelectedFirstBlock = false;
     let isSelectedLastBlock = false;
@@ -165,6 +169,11 @@ export class RTEListBlock extends RTEBlock {
       this.parent.apply(new RemoveChildAction(this));
     }
   }
+  /**
+   * Inserts an image block into a rich text editor block based on the parent block type.
+   *
+   * @param {InsertImageToBlockAction} action - Modify action
+   */
   insertImage(action) {
     const imageBlock = action.imageBlockToBeInserted;
     if (this.parent['type'] !== 'list-item') {
@@ -174,10 +183,15 @@ export class RTEListBlock extends RTEBlock {
       this.parent.apply(action);
     }
   }
+  /**
+   * Removes a specified block and handles the removal of nested lists if necessary.
+   *
+   * @param {RTEBlock} blockToBeRemoved - block that will be removed
+   */
   removeListItemBlock(blockToBeRemoved) {
     super.removeChildBlock(blockToBeRemoved);
     if (this.blocks.length === 0 && this.parent) {
-      // The parent is a list item mean the current block is a nest list, so we need use RemoveNestListAction to remove the item
+      // 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 (this.parent instanceof RTEListItemBlock) {
         this.parent.apply(new RemoveNestListAction(this));
       }