@globalpayments/vega 2.34.1 → 2.36.0

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;

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

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

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

@@ -0,0 +1,9 @@
+import { RTEListItemBlock } from '../../blocks/list-item-block';
+import { RTERenderContext } from '../../../interface';
+import { RTEBlockTextNodesRenderer } from './block-text-nodes-renderer.abstract';
+declare class RTEListItemBlockRenderer extends RTEBlockTextNodesRenderer {
+  render(block: RTEListItemBlock, renderContext: RTERenderContext): HTMLElement;
+  private renderChildren;
+}
+declare const _default: RTEListItemBlockRenderer;
+export default _default;

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

@@ -0,0 +1,11 @@
+import { RTERenderContext } from '../../../interface';
+import { RTETextBlock } from '../../blocks/text-block';
+import { RTEBlockTextNodesRenderer } from './block-text-nodes-renderer.abstract';
+import { RTEBlock } from '../../blocks/block.abstract';
+declare class RTETextBlockRenderer extends RTEBlockTextNodesRenderer {
+  canHandle(block: RTEBlock): boolean;
+  render(block: RTETextBlock, renderContext: RTERenderContext): HTMLElement;
+  private getBlockTagByType;
+}
+declare const _default: RTETextBlockRenderer;
+export default _default;

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

@@ -0,0 +1,10 @@
+import { RTENodeRenderer } from './node-renderer.abstract';
+import { RTEImageNode } from '../../nodes/image-node';
+import { RTERenderContext } from '../../../interface';
+declare class RTEImageNodeRenderer extends RTENodeRenderer {
+  render(node: RTEImageNode, renderContext: RTERenderContext): HTMLElement;
+  private renderImage;
+  private handleChange;
+}
+declare const _default: RTEImageNodeRenderer;
+export default _default;

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

@@ -0,0 +1,21 @@
+import { AnnotationStyle, RTERenderContext } from '../../../interface';
+import { Nullable } from '../../../../../types/general';
+import { RTENode } from '../../nodes/node.abstract';
+export declare abstract class RTENodeRenderer {
+  abstract render(node: RTENode, renderContext?: RTERenderContext): HTMLElement;
+  protected registerRef(ref: Nullable<HTMLElement>, node: RTENode): void;
+  /**
+   * Get styles from annotations
+   *
+   * @param {RTENode} node - The DTO node
+   * @returns {AnnotationStyle} - Annotation style
+   */
+  protected getStyles(node: RTENode): AnnotationStyle;
+  /**
+   * Get classes from annotations
+   *
+   * @param {RTENode} node - The DTO node
+   * @returns {AnnotationStyle} - Annotation style
+   */
+  protected getClasses(node: RTENode): string;
+}

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

@@ -0,0 +1,9 @@
+import { RTENodeRenderer } from './node-renderer.abstract';
+import { RTETextNode } from '../../nodes/text-node';
+import { Nullable } from '../../../../../types/general';
+declare class RTETextNodeRenderer extends RTENodeRenderer {
+  render(node: RTETextNode): HTMLElement;
+  protected registerRef(ref: Nullable<HTMLElement>, node: RTETextNode): void;
+}
+declare const _default: RTETextNodeRenderer;
+export default _default;

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/ul-not-li-child-to-rte-list-item-block.d.ts

@@ -0,0 +1,31 @@
+import { Nullable } from '../../../../../../types/general';
+import { RTEContentBlock } from '../../../../interface';
+import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.abstract';
+/** Transform child element of UL element which are not LI element to list item block DTO */
+export declare class ULNotLiChildToRTEListItemBlockStrategy extends BlockToRTEBlockStrategyAbstract {
+  /**
+   * Can be handle.
+   *
+   * @param {HTMLElement[]} elementsArray - Current elements.
+   * @param {number} currentIndex - Current element index.
+   * @returns {number} - can be handled element count.
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * Parse to a list item block.
+   *
+   * @param {HTMLElement[]} elementsArray - Current elements.
+   * @returns {Nullable<RTEContentBlock>} - List item block.
+   */
+  handle(elementsArray: HTMLElement[]): Nullable<RTEContentBlock>;
+  /**
+   * Append child blocks.
+   */
+  appendChildBlocks(): void;
+  /**
+   * Should continue process to child elements.
+   *
+   * @returns {boolean} - boolean.
+   */
+  shouldProceedToElementChildren(): boolean;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/value-controller.d.ts

@@ -19,6 +19,10 @@ export declare class ValueController extends VegaSlimmer {
    * Component lifecycle - [connectedCallback]{@link VegaRichTextEditor.disconnectedCallback}
    */
   disconnectedCallback(): void;
+  /**
+   * Component lifecycle - [componentWillLoad]{@link VegaRichTextEditor.componentWillLoad}
+   */
+  componentWillLoad(): void;
   /**
    * Watches the value of the editor and updates the internal value.
    */

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

@@ -123,7 +123,9 @@ export declare class VegaRichTextEditor {
    */
   rows: number;
   /**
-   * Specifies the value of the rich text editor
+   * Specifies the value of the rich text editor, which can be either VegaRTEContent or VegaRTEContentBlock.
+   * It is recommended to use the VegaRTEContent type.
+   * Only in exceptional cases should the original data in the VegaRTEContentBlock type be used.
    *
    * @vegaVersion 2.34.0
    */

package/dist/types/components/vega-tab-group/slimmers/vega-tab-group/controllers/vega-tab-group-page-index-controller.d.ts

@@ -12,6 +12,12 @@ export declare class VegaTabGroupPageIndexController extends VegaSlimmer {
    * update the page index when component call watchSelectedTabDataTargetChange method
    */
   handleSelectedDataTargetChange(): void;
+  /**
+   * Update the page index after the tab click
+   *
+   * @param {string} selectedTabDataTarget the tab item property dataTarget
+   */
+  setCurrentPageIndexBySelectedTab(selectedTabDataTarget: string): void;
   /**
    * The `setPageIndex` function sets the current page index to the specified value.
    *
@@ -22,10 +28,4 @@ export declare class VegaTabGroupPageIndexController extends VegaSlimmer {
    * Update the current page index if tab pages array length change when delete the tab items
    */
   private setCurrentPageIndexWhenTabPagesChange;
-  /**
-   * Update the page index after the tab click
-   *
-   * @param {string} selectedTabDataTarget the tab item property dataTarget
-   */
-  private setCurrentPageIndexBySelectedTab;
 }

package/dist/types/components/vega-tab-group/slimmers/vega-tab-group/controllers/vega-tab-group-selected-target-controller.d.ts

@@ -4,6 +4,7 @@ import { VegaTabGroup } from '../../../vega-tab-group';
 export declare class VegaTabGroupSelectedTargetController extends VegaSlimmer {
   clickEventEmitter: VegaTabGroup['clickEventEmitter'];
   selectedTabDataTarget: VegaTabGroup['selectedTabDataTarget'];
+  vegaTabGroupPageIndexController: VegaTabGroup['vegaTabGroupPageIndexController'];
   /**
    * The function sets the selectedTabDataTarget property to the provided dataTarget value.
    *