@globalpayments/vega 2.34.1 → 2.35.0

package/dist/types/components/vega-rich-text-editor/dto/blocks/image-block.d.ts

@@ -1,4 +1,4 @@
-import { RTEBlockType, VegaRTEImageBlock, RTERenderContext } from '../../interface';
+import { RTEBlockType, VegaRTEImageBlock } from '../../interface';
 import { RTEBlock } from './block.abstract';
 import { RTEImageNode } from '../nodes/image-node';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
@@ -11,18 +11,36 @@ export declare class RTEImageBlock extends RTEBlock {
   nodes: RTEImageNode[];
   parent: VegaRTEContent;
   constructor(id: string);
+  /**
+   * 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: VegaRTEImageBlock): RTEImageBlock;
+  /**
+   * @inheritDoc
+   */
   toJSON(): VegaRTEImageBlock;
+  /**
+   * @inheritDoc
+   */
   isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
   getLastNode(): RTEImageNode;
-  render(renderContext?: RTERenderContext): HTMLElement;
   /**
-   * Apply modify action to block
+   * Apply a modify action to block
    *
    * @param {ModifyContentAction} action - Modify action
    */
   protected doModifyActionApply(action: ModifyContentAction): void;
-  private registerRef;
+  /**
+   * 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.
+   */
   private removeChildNode;
   /**
    * The image offset should be 0 or 1
@@ -30,14 +48,60 @@ export declare 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
    */
   private splitImageNodes;
+  /**
+   * 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.
+   */
   private cloneWithNodes;
+  /**
+   * 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.
+   */
   private breakSingleBlock;
+  /**
+   * 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.
+   */
   private lineBreakSingleBlock;
+  /**
+   * 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.
+   */
   private isCaretPositionAtStart;
+  /**
+   * 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`.
+   */
   private isCaretPositionAtEnd;
+  /**
+   * 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.
+   */
   private lineBreakMultipleBlocks;
+  /**
+   * Deletes content from a block node based on specific conditions.
+   *
+   * @param {DeleteBlockContentAction} action - Delete block content action
+   */
   private deleteNodeContent;
   /**
    * Image will always create new image block

package/dist/types/components/vega-rich-text-editor/dto/blocks/list-block.d.ts

@@ -1,29 +1,71 @@
 import { RTEBlock } from './block.abstract';
-import { RTERenderContext, VegaRTEListBlock, VegaRTEListBlockType } from '../../interface';
+import { VegaRTEListBlock, VegaRTEListBlockType } from '../../interface';
 import { RTEListItemBlock } from './list-item-block';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 import { VegaRTEContent } from '../content-state';
 import { RTETextNode } from '../nodes/text-node';
+/**
+ * List block
+ */
 export declare class RTEListBlock extends RTEBlock {
   type: VegaRTEListBlockType;
   blocks: RTEListItemBlock[];
   parent: RTEListItemBlock | VegaRTEContent;
   constructor(id: string, type: VegaRTEListBlockType);
+  /**
+   * 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: VegaRTEListBlock): RTEListBlock;
+  /**
+   * @inheritDoc
+   */
   toJSON(): VegaRTEListBlock;
+  /**
+   * @inheritDoc
+   */
   isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
   getLastNode(): RTETextNode;
-  render(renderContext?: RTERenderContext): HTMLElement;
   /**
    * Apply a modify action to block
    *
    * @param {ModifyContentAction} action - Modify action
    */
   protected doModifyActionApply(action: ModifyContentAction): void;
+  /**
+   * Converts a RTEListItemBlock to a RTETextBlock representing a paragraph.
+   *
+   * @param {RTEListItemBlock} block - The block that will be covered
+   * @returns {RTETextBlock} Returns a `RTETextBlock`.
+   */
   private toParagraph;
-  private registerRef;
+  /**
+   * Covert block to List
+   *
+   * @param {TransformListAction} action - Modify action
+   */
   private convertToList;
+  /**
+   * Covert block to paragraph
+   *
+   * @param {TransformListAction} action - Modify action
+   */
   private convertToParagraph;
+  /**
+   * Inserts an image block into a rich text editor block based on the parent block type.
+   *
+   * @param {InsertImageToBlockAction} action - Modify action
+   */
   private insertImage;
+  /**
+   * Removes a specified block and handles the removal of nested lists if necessary.
+   *
+   * @param {RTEBlock} blockToBeRemoved - block that will be removed
+   */
   private removeListItemBlock;
 }

package/dist/types/components/vega-rich-text-editor/dto/blocks/list-item-block.d.ts

@@ -1,32 +1,97 @@
-import { VegaRTEListItemBlock, RTERenderContext } from '../../interface';
+import { VegaRTEListItemBlock } from '../../interface';
 import { RTETextNode } from '../nodes/text-node';
 import { RTEListBlock } from './list-block';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 import { RTETextBlock } from './text-block';
 import { RTEBlock } from './block.abstract';
+/**
+ * List item block
+ */
 export declare class RTEListItemBlock extends RTETextBlock {
   children?: RTEListBlock[];
   parent: RTEListBlock;
   constructor(id: string, children?: RTEListBlock[]);
+  /**
+   * Converts a VegaRTEListItemBlock object to an RTEListItemBlock
+   *
+   * @param {VegaRTEListBlock} block - Converts a `VegaRTEListItemBlock` object into an `RTEListItemBlock`.
+   * @returns {RTEListBlock} Return an instance of `RTEListItemBlock`
+   */
   static from(block: VegaRTEListItemBlock): RTEListItemBlock;
+  /**
+   * @inheritDoc
+   */
   toJSON(): VegaRTEListItemBlock;
+  /**
+   * @inheritDoc
+   */
   cloneWithNodes(nodes: RTETextNode[]): RTEBlock;
+  /**
+   * @inheritDoc
+   */
   isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
   getLastNode(): RTETextNode;
-  render(renderContext?: RTERenderContext): HTMLElement;
   /**
    * Apply a modify action to block
    *
    * @param {ModifyContentAction} action - Modify action
    */
   protected doModifyActionApply(action: ModifyContentAction): void;
-  private renderChildren;
+  /**
+   * Remove the list child node
+   *
+   * @param {RemoveChildAction} action - Modify action
+   */
   private removeListChildNode;
+  /**
+   * Remove the nest list
+   *
+   * @param {RemoveNestListAction} action - Modify action
+   */
   private removeNestList;
+  /**
+   * Iterates through a list of RTEListBlock and sets their parent property to the current object, then replaces the children property with the new list.
+   *
+   * @param {RTEListBlock[]} newList - new list that you want to replace the existing children of the current object with.
+   */
   private replaceNestList;
+  /**
+   * Split list item block
+   *
+   * @param {SplitBlockWithNodeAction} action - Modify action
+   */
   private splitListItemBlock;
+  /**
+   * 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.
+   * @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.
+   */
   private breakSingleListItemBlock;
+  /**
+   * 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.
+   * @returns {RTEBlock} Returns a `RTEBlock`.
+   */
   private breakListItemAtEnd;
+  /**
+   * Delete list node content
+   *
+   * @param {DeleteBlockContentAction} action - Modify action
+   */
   private deleteListNodeContent;
+  /**
+   * Copy the inline style to new node
+   *
+   * @param {RTETextNode} needCopedNode - The node that needed to be copied to
+   * @returns {RTETextNode} Returns a `RTETextNode`.
+   */
   private copyInlineStyleToNewNode;
 }

package/dist/types/components/vega-rich-text-editor/dto/blocks/text-block.d.ts

@@ -1,4 +1,4 @@
-import { VegaRTETextBlock, VegaRTETextBlockType, VegaRTEBlockAnnotations, RTERenderContext, VegaRTETextStyleType } from '../../interface';
+import { VegaRTETextBlock, VegaRTETextBlockType, VegaRTEBlockAnnotations, VegaRTETextStyleType } from '../../interface';
 import { RTETextNode } from '../nodes/text-node';
 import { Nullable } from '../../../../types/general';
 import { BlockAnnotation, BlockAnnotationTypeEnum } from '../annotations/block-annotation.abstract';
@@ -16,6 +16,12 @@ export declare class RTETextBlock extends RTEBlock {
   nodes: RTETextNode[];
   parent: VegaRTEContent | RTEListBlock;
   constructor(id: string, type: VegaRTETextBlockType);
+  /**
+   * Converts a VegaRTETextBlock into an RTETextBlock.
+   *
+   * @param {VegaRTETextBlock} block - The block object
+   * @returns {RTETextBlock} A RTETextBlock class
+   */
   static from(block: VegaRTETextBlock): RTETextBlock;
   /**
    * The function `createAnnotationEntity` creates a block annotation entity based on the provided type
@@ -30,15 +36,41 @@ export declare class RTETextBlock extends RTEBlock {
    * `BlockAnnotationTypeEnum` and a `BlockAnnotation` object.
    */
   protected static createAnnotationEntity(type: keyof VegaRTEBlockAnnotations | 'textStyle', value: unknown): Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>;
+  /**
+   * Checks if a given text block type is one of the acceptable text styles.
+   *
+   * @param {VegaRTETextBlockType} type - The text block type
+   * @returns {boolean} Return a boolean value indicating whether the `type` parameter is valid.
+   */
   protected static isAcceptableTextStyle(type: VegaRTETextBlockType): type is VegaRTETextStyleType;
+  /**
+   * Merges RTETextNode nodes based on certain conditions.
+   *
+   * @param {AnnotationAction} action - AnnotationAction
+   */
   mergeNodes(action: AnnotationAction): void;
+  /**
+   * @inheritDoc
+   */
   toJSON(): VegaRTETextBlock;
+  /**
+   * Clone the nodes to a new block
+   *
+   * @param {RTEBlock} nodes - The nodes will be copied
+   * @returns {RTEBlock} New block
+   */
   cloneWithNodes(nodes: RTETextNode[]): RTEBlock;
+  /**
+   * @inheritDoc
+   */
   isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
   getLastNode(): RTETextNode;
-  render(renderContext?: RTERenderContext, children?: Nullable<HTMLElement[]>): HTMLElement;
-  protected registerRef(ref: Nullable<HTMLElement>): void;
-  protected renderNodes(renderConfig?: RTERenderContext): HTMLElement[];
+  /**
+   * @inheritDoc
+   */
   protected doAnnotationActionApply(action: AnnotationAction): void;
   /**
    * Apply a modify action to block
@@ -46,17 +78,90 @@ export declare class RTETextBlock extends RTEBlock {
    * @param {ModifyContentAction} action - Modify action
    */
   protected doModifyActionApply(action: ModifyContentAction): void;
+  /**
+   * Splits a text node at a specified offset within a block of nodes and returns a new block with the split nodes.
+   *
+   * @param {RTETextNode} splitNode - The text node that will be split
+   * @param {number} startOffsetOfNode - The index at which will split the text content of the `splitNode`.
+   * @returns {Nullable<RTEBlock>} return either an RTEBlock object or null.
+   */
   protected splitTextNodeBlock(splitNode: RTETextNode, startOffsetOfNode: number): Nullable<RTEBlock>;
+  /**
+   * Checks if the caret position is at the start of a specified RTETextNode.
+   *
+   * @param {RTETextNode} node - `RTETextNode` - 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 RTETextNode.
+   */
   protected isCaretPositionAtStart(node: RTETextNode, startOffset: number): boolean;
+  /**
+   * Checks if the caret position is at the end of a specified RTETextNode.
+   *
+   * @param {RTETextNode} node - `RTETextNode` - 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 RTETextNode.
+   */
   protected isCaretPositionAtEnd(node: RTETextNode, startOffset: number): boolean;
+  /**
+   * lineBreakSingleBlock
+   *
+   * @param {RTETextNode} splitNode -
+   * @param {number} startOffsetOfNode -
+   * @returns {Nullable<RTETextNode>} Nullable<RTETextNode>
+   */
   protected lineBreakSingleBlock(splitNode: RTETextNode, startOffsetOfNode: number): Nullable<RTETextNode>;
+  /**
+   * lineBreakMultipleBlocks
+   *
+   * @param {RTEBlock[]} selectedBlocks -
+   * @returns {Nullable<RTETextNode>} Nullable<RTETextNode>
+   */
   protected lineBreakMultipleBlocks(selectedBlocks: RTEBlock[]): Nullable<RTETextNode>;
+  /**
+   * deleteNodeContent
+   *
+   * @param {DeleteBlockContentAction} action - ModifyContentAction
+   */
   protected deleteNodeContent(action: DeleteBlockContentAction): void;
+  /**
+   * Remove the child node
+   *
+   * @param {RemoveChildAction} action - Modify action
+   */
   private removeChildNode;
+  /**
+   * mergeLineBreakNodes
+   *
+   * @param {RTENode[]} beforeNodes -
+   * @param {RTETextNode} lineBreakNode -
+   * @param {RTENode[]} afterNodes -
+   */
   private mergeLineBreakNodes;
-  private getBlockTagByType;
+  /**
+   * breakSingleTextBlock
+   *
+   * @param {RTETextNode} splitNode -
+   * @param {number} startOffsetOfNode -
+   * @returns {Nullable<RTEBlock>} Nullable<RTEBlock>
+   */
   private breakSingleTextBlock;
+  /**
+   * convertParagraphToList
+   *
+   * @param {TransformListAction} action - ModifyContentAction
+   */
   private convertParagraphToList;
+  /**
+   * insertImage
+   *
+   * @param {InsertImageToBlockAction} action - ModifyContentAction
+   */
   private insertImage;
+  /**
+   * copyInlineStyleToNewParagraph
+   *
+   * @param {RTETextNode} needCopedNode -
+   * @returns {RTETextBlock} RTETextBlock
+   */
   private copyInlineStyleToNewParagraph;
 }

package/dist/types/components/vega-rich-text-editor/dto/nodes/image-node.d.ts

@@ -1,18 +1,34 @@
 import { NodeTypeEnum, RTENode } from './node.abstract';
 import { RTEImageBlock } from '../blocks/image-block';
-import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, RTERenderContext, VegaRTEImageNode } from '../../interface';
+import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTEImageNode } from '../../interface';
 import { ImageAnnotationAction } from '../actions/image-annotation-action';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
+/**
+ * Image node
+ */
 export declare class RTEImageNode extends RTENode {
   readonly type: NodeTypeEnum;
   parentBlock: RTEImageBlock;
   url: string;
   constructor(id: string, url: string, parentBlock: RTEImageBlock, annotationMap?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
-  static from(image: VegaRTEImageNode, parentBlock: RTEImageBlock): RTEImageNode;
+  /**
+   * Converts a VegaRTEImageNode into an RTEImageNode by mapping nodes and creating annotations.
+   *
+   * @param {VegaRTEImageNode} node - The node to be converted.
+   * @param {RTEImageBlock} parentBlock - The parent block
+   * @returns {RTEImageBlock} An instance of `RTEImageBlock`
+   */
+  static from(node: VegaRTEImageNode, parentBlock: RTEImageBlock): RTEImageNode;
+  /**
+   * @inheritDoc
+   */
   toJSON(): VegaRTEImageNode;
-  render({ editable }?: RTERenderContext): HTMLElement;
+  /**
+   * @inheritDoc
+   */
   protected doAnnotationActionApply(action: ImageAnnotationAction): void;
+  /**
+   * @inheritDoc
+   */
   protected doModifyActionApply(action: ModifyContentAction): void;
-  private registerRef;
-  private renderImage;
 }

package/dist/types/components/vega-rich-text-editor/dto/nodes/node.abstract.d.ts

@@ -1,4 +1,4 @@
-import { AnnotationStyle, RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, RTERenderContext, VegaRTEBaseNode } from '../../interface';
+import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTEBaseNode } from '../../interface';
 import { AnnotationAction } from '../actions/annotation-action.abstract';
 import { RTEBlock } from '../blocks/block.abstract';
 import { Nullable } from '../../../../types/general';
@@ -36,25 +36,12 @@ export declare abstract class RTENode {
    * @returns {this} - Node
    */
   apply(action: AnnotationAction | ModifyContentAction): this;
-  abstract render(renderContext?: RTERenderContext): HTMLElement;
   /**
    * apply annotation action or modify content action
    *
    * @param {AnnotationAction | ModifyContentAction} action annotation type action or modify content type action
    */
   protected doApply(action: AnnotationAction | ModifyContentAction): void;
-  /**
-   * Get styles from annotations
-   *
-   * @returns {AnnotationStyle} - Annotation style
-   */
-  protected getStyles(): AnnotationStyle;
-  /**
-   * Get classes from annotations
-   *
-   * @returns {AnnotationStyle} - Annotation style
-   */
-  protected getClasses(): string;
   /**
    * Flush the value change
    */

package/dist/types/components/vega-rich-text-editor/dto/nodes/text-node.d.ts

@@ -6,26 +6,110 @@ import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 export declare type Link = {
   href?: string;
 };
+/**
+ * Text node
+ */
 export declare class RTETextNode extends RTENode {
   readonly type: NodeTypeEnum;
   text: string;
   parentBlock: RTETextBlock;
   constructor(id: string, text: string, parentBlock: RTETextBlock, annotationMap?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
+  /**
+   * Creates an RTETextNode from a VegaRTETextNode with annotations and a parent RTETextBlock.
+   *
+   * @param {VegaRTETextNode} richText - A rich text node
+   * @param {RTETextBlock} parentBlock - Parent block
+   * @returns {RTETextNode} an RTETextNode
+   */
   static from(richText: VegaRTETextNode, parentBlock: RTETextBlock): RTETextNode;
+  /**
+   * Creates different types of text annotations based on the provided type and value.
+   *
+   * @param {keyof VegaRTETextAnnotations} type - The key of the type.
+   * @param {unknown} value - The value that will be used to create the specific type of annotation entity based on the `type` provided.
+   * @returns {Nullable<[RTENodeAnnotationMapKey, RTENodeAnnotationMapValue]>} Returning a nullable tuple containing a key and a
+   * value from the `RTENodeAnnotationMapKey` and `RTENodeAnnotationMapValue` types.
+   */
   private static createAnnotationEntity;
+  /**
+   * @inheritDoc
+   */
   toJSON(): VegaRTETextNode;
+  /**
+   * Creates a new RTETextNode with the specified text and copies the parent block and annotation map from the original node.
+   *
+   * @param {string} text - The text content of the RTETextNode that will be created.
+   * @returns {RTETextNode} An new RTETextNode
+   */
   cloneWithText(text: string): RTETextNode;
+  /**
+   * Checks if a node is empty
+   *
+   * @returns {boolean}  It returns `true` if the node is empty
+   */
   isEmpty(): boolean;
-  render(): HTMLElement;
+  /**
+   * @inheritDoc
+   */
   protected doAnnotationActionApply(action: AnnotationAction): void;
+  /**
+   * @inheritDoc
+   */
   protected doModifyActionApply(action: ModifyContentAction): void;
-  private registerRef;
+  /**
+   * Split text node with range
+   *
+   * @param {TextSplittableAction} action - Annotation action
+   * @param {Range} range - Selection range
+   * @returns {RTETextNode[] | this} RTETextNode array
+   */
   private splitTextNode;
+  /**
+   * Apply action to node
+   *
+   * @param {RTETextNode} node - Text node
+   * @param {AnnotationAction} action - AnnotationAction
+   */
   private applyActionToNode;
+  /**
+   * 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).
+   */
   private replaceSelectedText;
+  /**
+   * Updates the text content of a node and unlink the node if it is a link node and the text is deleted.
+   *
+   * @param {string} newText - The new text string
+   */
   private updateText;
+  /**
+   * Checks if a node has an annotation with the key 'LINK'.
+   *
+   * @returns {boolean} A boolean value indicating whether the `annotationMap` has a key 'LINK'.
+   */
   private isLinkNode;
+  /**
+   * Whether a given range should be split based on various conditions within the range.
+   *
+   * @param {Range} range - Selection range
+   * @returns {boolean} Returns a boolean value indicating whether the
+   * selection range should be split.
+   */
   private shouldSplitSelection;
+  /**
+   * Sync up the selected node by change manager
+   *
+   * @param {RTETextNode} selectedNode - The selected node
+   */
   private syncUpSelectedNodes;
+  /**
+   * Insert the new node at the start offset
+   *
+   * @param {number} startOffset - The start position offset
+   * @param {AnnotationAction} action - AnnotationAction
+   * @returns {RTETextNode[]} - RTETextNode array
+   */
   private insertNewNode;
 }

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/block-renderer.abstract.d.ts

@@ -0,0 +1,28 @@
+import { RTEBlock } from '../../blocks/block.abstract';
+import { AnnotationStyle, RTERenderContext } from '../../../interface';
+import { Nullable } from '../../../../../types/general';
+export declare abstract class RTEBlockRenderer {
+  /**
+   * Check whether the block can be handled by this renderer
+   *
+   * @param {RTEBlock} block - RTE block entity
+   * @returns {boolean} - can be handled or not
+   */
+  canHandle?(block: RTEBlock): boolean;
+  abstract render(block: RTEBlock, renderContext: RTERenderContext): HTMLElement;
+  protected registerRef(ref: Nullable<HTMLElement>, block: RTEBlock): void;
+  /**
+   * Get styles from annotations
+   *
+   * @param {RTEBlock} block - RTE block entity
+   * @returns {AnnotationStyle} - Annotation style
+   */
+  protected getStyles(block: RTEBlock): AnnotationStyle;
+  /**
+   * Get classes from annotations
+   *
+   * @param {RTEBlock} block - RTE block entity
+   * @returns {AnnotationStyle} - Annotation style
+   */
+  protected getClasses(block: RTEBlock): string;
+}

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/block-text-nodes-renderer.abstract.d.ts

@@ -0,0 +1,14 @@
+import { RTERenderContext } from '../../../interface';
+import { RTETextBlock } from '../../blocks/text-block';
+import { RTEBlockRenderer } from './block-renderer.abstract';
+/**
+ * Abstract class for rendering blocks that contain text nodes with support for rendering text with link styles.
+ */
+export declare abstract class RTEBlockTextNodesRenderer extends RTEBlockRenderer {
+  protected renderNodes(block: RTETextBlock, renderContext: RTERenderContext): HTMLElement[];
+  private renderLinkNodes;
+  private groupNodesByLink;
+  private isLinkGroup;
+  private renderLinkEditorWrapper;
+  private renderLink;
+}

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/image-block-renderer.d.ts

@@ -0,0 +1,10 @@
+import { RTEImageBlock } from '../../blocks/image-block';
+import { RTEBlockRenderer } from './block-renderer.abstract';
+import { RTERenderContext } from '../../../interface';
+import { RTEBlock } from '../../blocks/block.abstract';
+declare class RTEImageBlockRenderer extends RTEBlockRenderer {
+  canHandle(block: RTEBlock): boolean;
+  render(block: RTEImageBlock, renderContext: RTERenderContext): HTMLElement;
+}
+declare const _default: RTEImageBlockRenderer;
+export default _default;