@globalpayments/vega 2.33.0 → 2.34.1

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

@@ -0,0 +1,167 @@
+import { AnnotationStyle, RTEBlockType, RTERenderContext, VegaRTEBlockAnnotations, VegaRTEBlockBase } from '../../interface';
+import { BlockAnnotation, BlockAnnotationTypeEnum } from '../annotations/block-annotation.abstract';
+import { AnnotationAction } from '../actions/annotation-action.abstract';
+import { Nullable } from '../../../../types/general';
+import { ModifyContentAction } from '../actions/modify-content-action.abstract';
+import { VegaRTEContent } from '../content-state';
+import { InternalAnnotationTypeEnum } from '../annotations/annotation.abstract';
+import { LinkGroupAnnotation } from '../annotations/link-group-annotation';
+import { RTENode } from '../nodes/node.abstract';
+import { BlockBaseOperator } from '../helper/block-base-operator';
+/**
+ * Abstract class for block
+ */
+export declare abstract class RTEBlock extends BlockBaseOperator {
+  id: string;
+  protected annotationMap: Map<keyof typeof BlockAnnotationTypeEnum | InternalAnnotationTypeEnum.LINK_GROUP, BlockAnnotation | LinkGroupAnnotation>;
+  abstract type: RTEBlockType;
+  abstract parent: VegaRTEContent | RTEBlock;
+  protected constructor(id: string);
+  /**
+   * The function `createAnnotationEntity` creates a block annotation entity based on the provided type
+   * and value.
+   *
+   * @param {keyof VegaRTEBlockAnnotations} type - The `type` parameter is a key of the `VegaRTEBlockAnnotations` enum, which specifies
+   * the type of annotation entity to create.
+   * @param {unknown} value - The `value` parameter in the `createAnnotationEntity` function is the value
+   * that will be used to create the annotation entity. It can be of any type depending on the specific
+   * annotation being created.
+   * @returns {Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>} The `createAnnotationEntity` function returns a nullable tuple containing a
+   * `BlockAnnotationTypeEnum` and a `BlockAnnotation` object.
+   */
+  protected static createAnnotationEntity(type: keyof VegaRTEBlockAnnotations, value: unknown): Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>;
+  /**
+   * Class to JSON object
+   *
+   * @returns {VegaRTEBlockBase} - JSON object
+   */
+  toJSON(): VegaRTEBlockBase;
+  /**
+   * Get annotation by type
+   *
+   * @param {keyof typeof BlockAnnotationTypeEnum} type - Annotation type
+   * @returns {Nullable<BlockAnnotation> | Nullable<LinkGroupAnnotation>} - Annotation
+   */
+  getAnnotationByType<T extends BlockAnnotation | LinkGroupAnnotation>(type: keyof typeof BlockAnnotationTypeEnum | InternalAnnotationTypeEnum.LINK_GROUP): Nullable<T>;
+  /**
+   * Apply action to block
+   *
+   * @param {AnnotationAction} action - Annotation action
+   */
+  apply(action: AnnotationAction | ModifyContentAction): void;
+  abstract render(renderContext?: RTERenderContext): HTMLElement;
+  /**
+   * Apply action to block
+   *
+   * @param {AnnotationAction|ModifyContentAction} action - Annotation action
+   */
+  protected doApply(action: AnnotationAction | ModifyContentAction): void;
+  /**
+   * Apply annotation action to block
+   *
+   * @param {AnnotationAction} action - Annotation action
+   */
+  protected applyAnnotationAction(action: AnnotationAction): void;
+  /**
+   * Get styles from annotations
+   *
+   * @returns {AnnotationStyle} - Annotation style
+   */
+  protected getStyles(): AnnotationStyle;
+  /**
+   * Get classes from annotations
+   *
+   * @returns {AnnotationStyle} - Annotation style
+   */
+  protected getClasses(): string;
+  /**
+   * Appends a list of RTENode objects to the current node's child nodes and sets the parent block of each node to the current node.
+   *
+   * @param {RTENode[]} nodesToBeAppended - An array of `RTENode` objects that you want to append to the current block.
+   */
+  protected appendChildNodes(nodesToBeAppended: RTENode[]): void;
+  /**
+   * Merges the child nodes of two RTEBlocks if they have the same type or both are not images.
+   *
+   * @param {RTEBlock} secondBlock - A block of content in a rich text editor, such as a paragraph, heading, image, etc.
+   */
+  protected mergeTwoBlocksNodes(secondBlock: RTEBlock): void;
+  /**
+   * Concat the child nodes of multiple RTEBlocks if both are not images.
+   *
+   * @param {RTEBlock[]} blocks - multiple block of content in a rich text editor, such as a paragraph, heading, image, etc.
+   * @returns {RTENode[]} Array of connected block nodes
+   */
+  protected concatBlocksNodes(blocks: RTEBlock[]): RTENode[];
+  /**
+   * Returns the previous node relative to the current node in a rich text editor structure.
+   *
+   * @param {RTENode} currentNode - An object of type `RTENode`.
+   * @returns {Nullable<RTENode>} the previous block last node
+   */
+  protected getPreviousNode(currentNode: RTENode): Nullable<RTENode>;
+  /**
+   * Returns the next node relative to the current node in a rich text editor structure.
+   *
+   * @param {RTENode} currentNode - An object of type `RTENode`.
+   * @returns {Nullable<RTENode>} the next block first node
+   */
+  protected getNextNode(currentNode: RTENode): Nullable<RTENode>;
+  /**
+   * Determines if a given node is the first node within the current state.
+   *
+   * @param {RTENode} currentNode - An object representing a node in a rich text editor (RTE).
+   * @returns {boolean} True or false;
+   */
+  protected isContentFirstNode(currentNode: RTENode): boolean;
+  /**
+   * Returns the last node within a given RTE block, handling different block types accordingly.
+   *
+   * @param {RTEBlock} currentBlock - Returns the last node within that block.
+   * @returns {Nullable<RTENode>} Returns the last node of the given `currentBlock` object.
+   */
+  protected getBlockLastNode(currentBlock: RTEBlock): Nullable<RTENode>;
+  /**
+   * Returns the first node within a given RTE block, handling different block types accordingly.
+   *
+   * @param {RTEBlock} currentBlock - Returns the first node within that block.
+   * @returns {Nullable<RTENode>} Returns the first node of the given `currentBlock` object.
+   */
+  protected getBlockFirstNode(currentBlock: RTEBlock): Nullable<RTENode>;
+  /**
+   * TODO: The getPreviousBlock add nest list support
+   * This function retrieves the previous block in a rich text editor, considering different scenarios such as being in a bullet list.
+   *
+   * @param {RTEBlock} currentBlock - Used to retrieve the previous block relative to the given `currentBlock` within a rich text editor context.
+   * @returns {Nullable<RTEBlock>} The previous block if existing
+   */
+  protected getPreviousBlock(currentBlock: RTEBlock): Nullable<RTEBlock>;
+  /**
+   * This function retrieves the next block in a rich text editor, considering different scenarios such as being in a bullet list.
+   *
+   * @param {RTEBlock} currentBlock - Used to retrieve the next block relative to the given `currentBlock` within a rich text editor context.
+   * @returns {Nullable<RTEBlock>} The next block if existing
+   */
+  protected getNextBlock(currentBlock: RTEBlock): Nullable<RTEBlock>;
+  /**
+   * Replaces a specific node with an array of nodes within a RTENode array.
+   *
+   * @param {RTENode} referNode - Used as a reference node to identify the node that needs to be replaced in the `nodes` array.
+   * @param {RTENode[]} nodes - An array of RTENode objects that you want to replace the `referNode` with in the `nodes` array.
+   */
+  protected replaceNodeWithNodes(referNode: RTENode, nodes: RTENode[]): void;
+  /**
+   * abstract method to apply annotation action in each block
+   *
+   * @param {AnnotationAction} action - Annotation action
+   */
+  protected doAnnotationActionApply?(action: AnnotationAction): void;
+  /**
+   * abstract method to be overridden in each block to verify whether the block is not empty
+   *
+   * @returns {boolean} true if the block is not empty
+   */
+  abstract isNotEmpty(): boolean;
+  abstract getLastNode(): RTENode;
+  protected abstract doModifyActionApply(action: ModifyContentAction): void;
+}

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

@@ -0,0 +1,48 @@
+import { RTEBlockType, VegaRTEImageBlock, RTERenderContext } from '../../interface';
+import { RTEBlock } from './block.abstract';
+import { RTEImageNode } from '../nodes/image-node';
+import { ModifyContentAction } from '../actions/modify-content-action.abstract';
+import { VegaRTEContent } from '../content-state';
+/**
+ * Image block
+ */
+export declare class RTEImageBlock extends RTEBlock {
+  readonly type: RTEBlockType;
+  nodes: RTEImageNode[];
+  parent: VegaRTEContent;
+  constructor(id: string);
+  static from(block: VegaRTEImageBlock): RTEImageBlock;
+  toJSON(): VegaRTEImageBlock;
+  isNotEmpty(): boolean;
+  getLastNode(): RTEImageNode;
+  render(renderContext?: RTERenderContext): HTMLElement;
+  /**
+   * Apply modify action to block
+   *
+   * @param {ModifyContentAction} action - Modify action
+   */
+  protected doModifyActionApply(action: ModifyContentAction): void;
+  private registerRef;
+  private removeChildNode;
+  /**
+   * The image offset should be 0 or 1
+   * <vega-rich-text-image-editor><img /></vega-rich-text-image-editor>
+   *
+   * @param {RTEImageNode} imageNode The split point image node
+   * @param {number} imageOffset The cursor point 0 | 1
+   */
+  private splitImageNodes;
+  private cloneWithNodes;
+  private breakSingleBlock;
+  private lineBreakSingleBlock;
+  private isCaretPositionAtStart;
+  private isCaretPositionAtEnd;
+  private lineBreakMultipleBlocks;
+  private deleteNodeContent;
+  /**
+   * Image will always create new image block
+   *
+   * @param {InsertImageToBlockAction} action insert image to current block
+   */
+  private insertImage;
+}

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

@@ -0,0 +1,29 @@
+import { RTEBlock } from './block.abstract';
+import { RTERenderContext, 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';
+export declare class RTEListBlock extends RTEBlock {
+  type: VegaRTEListBlockType;
+  blocks: RTEListItemBlock[];
+  parent: RTEListItemBlock | VegaRTEContent;
+  constructor(id: string, type: VegaRTEListBlockType);
+  static from(block: VegaRTEListBlock): RTEListBlock;
+  toJSON(): VegaRTEListBlock;
+  isNotEmpty(): boolean;
+  getLastNode(): RTETextNode;
+  render(renderContext?: RTERenderContext): HTMLElement;
+  /**
+   * Apply a modify action to block
+   *
+   * @param {ModifyContentAction} action - Modify action
+   */
+  protected doModifyActionApply(action: ModifyContentAction): void;
+  private toParagraph;
+  private registerRef;
+  private convertToList;
+  private convertToParagraph;
+  private insertImage;
+  private removeListItemBlock;
+}

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

@@ -0,0 +1,32 @@
+import { VegaRTEListItemBlock, RTERenderContext } 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';
+export declare class RTEListItemBlock extends RTETextBlock {
+  children?: RTEListBlock[];
+  parent: RTEListBlock;
+  constructor(id: string, children?: RTEListBlock[]);
+  static from(block: VegaRTEListItemBlock): RTEListItemBlock;
+  toJSON(): VegaRTEListItemBlock;
+  cloneWithNodes(nodes: RTETextNode[]): RTEBlock;
+  isNotEmpty(): boolean;
+  getLastNode(): RTETextNode;
+  render(renderContext?: RTERenderContext): HTMLElement;
+  /**
+   * Apply a modify action to block
+   *
+   * @param {ModifyContentAction} action - Modify action
+   */
+  protected doModifyActionApply(action: ModifyContentAction): void;
+  private renderChildren;
+  private removeListChildNode;
+  private removeNestList;
+  private replaceNestList;
+  private splitListItemBlock;
+  private breakSingleListItemBlock;
+  private breakListItemAtEnd;
+  private deleteListNodeContent;
+  private copyInlineStyleToNewNode;
+}

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

@@ -0,0 +1,62 @@
+import { VegaRTETextBlock, VegaRTETextBlockType, VegaRTEBlockAnnotations, RTERenderContext, VegaRTETextStyleType } from '../../interface';
+import { RTETextNode } from '../nodes/text-node';
+import { Nullable } from '../../../../types/general';
+import { BlockAnnotation, BlockAnnotationTypeEnum } from '../annotations/block-annotation.abstract';
+import { ModifyContentAction } from '../actions/modify-content-action.abstract';
+import { VegaRTEContent } from '../content-state';
+import { RTEBlock } from './block.abstract';
+import { AnnotationAction } from '../actions/annotation-action.abstract';
+import { RTEListBlock } from './list-block';
+import { DeleteBlockContentAction } from '../actions/delete-block-content-action';
+/**
+ * Text block
+ */
+export declare class RTETextBlock extends RTEBlock {
+  type: VegaRTETextBlockType;
+  nodes: RTETextNode[];
+  parent: VegaRTEContent | RTEListBlock;
+  constructor(id: string, type: VegaRTETextBlockType);
+  static from(block: VegaRTETextBlock): RTETextBlock;
+  /**
+   * The function `createAnnotationEntity` creates a block annotation entity based on the provided type
+   * and value.
+   *
+   * @param {keyof VegaRTEBlockAnnotations} type - The `type` parameter is a key of the `VegaRTEBlockAnnotations` enum, which specifies
+   * the type of annotation entity to create.
+   * @param {unknown} value - The `value` parameter in the `createAnnotationEntity` function is the value
+   * that will be used to create the annotation entity. It can be of any type depending on the specific
+   * annotation being created.
+   * @returns {Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>} The `createAnnotationEntity` function returns a nullable tuple containing a
+   * `BlockAnnotationTypeEnum` and a `BlockAnnotation` object.
+   */
+  protected static createAnnotationEntity(type: keyof VegaRTEBlockAnnotations | 'textStyle', value: unknown): Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>;
+  protected static isAcceptableTextStyle(type: VegaRTETextBlockType): type is VegaRTETextStyleType;
+  mergeNodes(action: AnnotationAction): void;
+  toJSON(): VegaRTETextBlock;
+  cloneWithNodes(nodes: RTETextNode[]): RTEBlock;
+  isNotEmpty(): boolean;
+  getLastNode(): RTETextNode;
+  render(renderContext?: RTERenderContext, children?: Nullable<HTMLElement[]>): HTMLElement;
+  protected registerRef(ref: Nullable<HTMLElement>): void;
+  protected renderNodes(renderConfig?: RTERenderContext): HTMLElement[];
+  protected doAnnotationActionApply(action: AnnotationAction): void;
+  /**
+   * Apply a modify action to block
+   *
+   * @param {ModifyContentAction} action - Modify action
+   */
+  protected doModifyActionApply(action: ModifyContentAction): void;
+  protected splitTextNodeBlock(splitNode: RTETextNode, startOffsetOfNode: number): Nullable<RTEBlock>;
+  protected isCaretPositionAtStart(node: RTETextNode, startOffset: number): boolean;
+  protected isCaretPositionAtEnd(node: RTETextNode, startOffset: number): boolean;
+  protected lineBreakSingleBlock(splitNode: RTETextNode, startOffsetOfNode: number): Nullable<RTETextNode>;
+  protected lineBreakMultipleBlocks(selectedBlocks: RTEBlock[]): Nullable<RTETextNode>;
+  protected deleteNodeContent(action: DeleteBlockContentAction): void;
+  private removeChildNode;
+  private mergeLineBreakNodes;
+  private getBlockTagByType;
+  private breakSingleTextBlock;
+  private convertParagraphToList;
+  private insertImage;
+  private copyInlineStyleToNewParagraph;
+}

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

@@ -0,0 +1,58 @@
+import { RTEContentBlock, VegaRTEContentBlock, ListType } from '../interface';
+import { RTEListBlock } from './blocks/list-block';
+import { RTETextBlock } from './blocks/text-block';
+import { ModifyContentAction } from './actions/modify-content-action.abstract';
+import { BlockBaseOperator } from './helper/block-base-operator';
+import { RTEListItemBlock } from './blocks/list-item-block';
+/**
+ * Class representing the content state of the rich text editor.
+ */
+export declare class VegaRTEContent extends BlockBaseOperator {
+  blocks: RTEContentBlock[];
+  constructor(blocks: RTEContentBlock[]);
+  /**
+   * Converts a JSON array of blocks to a class array of RTEContentBlock.
+   *
+   * @param {VegaRTEContentBlock[]} value The JSON array of blocks to convert.
+   * @returns {RTEContentBlock[]} The converted array of RTEContentBlock.
+   */
+  static fromJSON(value: VegaRTEContentBlock[]): VegaRTEContent;
+  /**
+   * Create an empty content state
+   *
+   * @returns {VegaRTEContent} An empty content state
+   */
+  static createEmptyContent(): VegaRTEContent;
+  /**
+   * Clones the content state.
+   *
+   * @returns {VegaRTEContent} The cloned content state.
+   */
+  clone(): VegaRTEContent;
+  /**
+   * Converts the content state to a JSON array of blocks.
+   *
+   * @returns {VegaRTEContentBlock[]} The JSON array of blocks.
+   */
+  toJSON(): VegaRTEContentBlock[];
+  /**
+   * Internal method to add the block item, remove the block item
+   *
+   * @param {ModifyContentAction} action - Modify content action
+   */
+  apply(action: ModifyContentAction): void;
+  /**
+   * Convert text to list.
+   *
+   * @param {RTETextBlock} block - block
+   * @returns {RTEListItemBlock} list item block dto.
+   */
+  toListItem(block: RTETextBlock): RTEListItemBlock;
+  /**
+   * create list.
+   *
+   * @param {ListType} type - type
+   * @returns {RTEListBlock} list block dto.
+   */
+  createList(type: ListType): RTEListBlock;
+}

package/dist/types/components/vega-rich-text-editor/dto/helper/block-base-operator.d.ts

@@ -0,0 +1,24 @@
+import { RTEBlock } from '../blocks/block.abstract';
+/** The class contains some common method to modify the blocks property */
+export declare class BlockBaseOperator {
+  blocks?: RTEBlock[];
+  /**
+   * Replaces a specific block with an array of blocks within a RTEContentBlock array.
+   *
+   * @param {RTEBlock} referBlock - Used as a reference block to identify the block that needs to be replaced in the `blocks` array.
+   * @param {RTEBlock[]} blocks - An array of RTEBlock objects that you want to replace the `referBlock` with in the `blocks` array.
+   */
+  protected replaceBlockWithBlocks(referBlock: RTEBlock, blocks: RTEBlock[]): void;
+  /**
+   * Appends new blocks to an array and sets their parent property to a specific type.
+   *
+   * @param {RTEBlock[]} newBlocks - An array of `RTEBlock` objects that are being passed to the `appendChildBlocks` method.
+   */
+  protected appendChildBlocks(newBlocks: RTEBlock[]): void;
+  /**
+   * Removes a specified RTEBlock from an array of blocks.
+   *
+   * @param {RTEBlock} blockToBeRemoved - The block that needs to be removed from the `blocks` array.
+   */
+  protected removeChildBlock(blockToBeRemoved: RTEBlock): void;
+}

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

@@ -0,0 +1,18 @@
+import { NodeTypeEnum, RTENode } from './node.abstract';
+import { RTEImageBlock } from '../blocks/image-block';
+import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, RTERenderContext, VegaRTEImageNode } from '../../interface';
+import { ImageAnnotationAction } from '../actions/image-annotation-action';
+import { ModifyContentAction } from '../actions/modify-content-action.abstract';
+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;
+  toJSON(): VegaRTEImageNode;
+  render({ editable }?: RTERenderContext): HTMLElement;
+  protected doAnnotationActionApply(action: ImageAnnotationAction): void;
+  protected doModifyActionApply(action: ModifyContentAction): void;
+  private registerRef;
+  private renderImage;
+}

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

@@ -0,0 +1,65 @@
+import { AnnotationStyle, RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, RTERenderContext, VegaRTEBaseNode } from '../../interface';
+import { AnnotationAction } from '../actions/annotation-action.abstract';
+import { RTEBlock } from '../blocks/block.abstract';
+import { Nullable } from '../../../../types/general';
+import { ModifyContentAction } from '../actions/modify-content-action.abstract';
+export declare enum NodeTypeEnum {
+  TEXT = "TEXT",
+  IMAGE = "IMAGE"
+}
+/**
+ * Abstract class for all nodes
+ */
+export declare abstract class RTENode {
+  id: string;
+  annotationMap: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>;
+  abstract readonly type: NodeTypeEnum;
+  abstract parentBlock: RTEBlock;
+  protected constructor(id: string, annotationMap?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
+  /**
+   * Get annotation by type
+   *
+   * @param {RTENodeAnnotationMapKey} type - Annotation type
+   * @returns {Nullable<RTENodeAnnotationMapValue>} - Annotation
+   */
+  getAnnotationByType<T extends RTENodeAnnotationMapValue>(type: RTENodeAnnotationMapKey): Nullable<T>;
+  /**
+   * Delete annotation by type
+   *
+   * @param {RTENodeAnnotationMapKey} type - Annotation type
+   */
+  deleteAnnotationByType(type: RTENodeAnnotationMapKey): void;
+  /**
+   * Apply action to node
+   *
+   * @param {AnnotationAction} action - Annotation action
+   * @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
+   */
+  protected flushChange(): void;
+  abstract toJSON(): VegaRTEBaseNode;
+  protected abstract doAnnotationActionApply(action: AnnotationAction): void;
+  protected abstract doModifyActionApply(action: ModifyContentAction): void;
+}

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

@@ -0,0 +1,31 @@
+import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTETextNode } from '../../interface';
+import { NodeTypeEnum, RTENode } from './node.abstract';
+import { AnnotationAction } from '../actions/annotation-action.abstract';
+import { RTETextBlock } from '../blocks/text-block';
+import { ModifyContentAction } from '../actions/modify-content-action.abstract';
+export declare type Link = {
+  href?: string;
+};
+export declare class RTETextNode extends RTENode {
+  readonly type: NodeTypeEnum;
+  text: string;
+  parentBlock: RTETextBlock;
+  constructor(id: string, text: string, parentBlock: RTETextBlock, annotationMap?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
+  static from(richText: VegaRTETextNode, parentBlock: RTETextBlock): RTETextNode;
+  private static createAnnotationEntity;
+  toJSON(): VegaRTETextNode;
+  cloneWithText(text: string): RTETextNode;
+  isEmpty(): boolean;
+  render(): HTMLElement;
+  protected doAnnotationActionApply(action: AnnotationAction): void;
+  protected doModifyActionApply(action: ModifyContentAction): void;
+  private registerRef;
+  private splitTextNode;
+  private applyActionToNode;
+  private replaceSelectedText;
+  private updateText;
+  private isLinkNode;
+  private shouldSplitSelection;
+  private syncUpSelectedNodes;
+  private insertNewNode;
+}

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

@@ -0,0 +1,102 @@
+import { Nullable } from '../../../types/general';
+import { RTENode } from './nodes/node.abstract';
+export declare type RTERangeOptions = {
+  startNode: Node | RTENode;
+  endNode: Node | RTENode;
+  startOffset: number;
+  endOffset: number;
+};
+/** Manages selection range for a rich text editor, providing methods to set, sync, and create native ranges based on RTENodes and Nodes. */
+export declare class RTERange {
+  private _startContainer;
+  private _endContainer;
+  private _startOffset;
+  private _endOffset;
+  private _startNode;
+  private _endNode;
+  private _oldNativeRange;
+  /**
+   * Initial the rte range properties
+   *
+   * @param {Node} [startContainer] The range start element.
+   * @param {Node} [endContainer] The range end element.
+   * @param {number} [startOffset] The range start element content offset, default value is 0.
+   * @param {number} [endOffset]  The range end element content offset, default value is 0.
+   * @param {RTENode} [startNode] The range start node, the start node could be null if the start element is root element.
+   * @param {RTENode} [endNode]  The range start node, the start node could be null if the start element is root element.
+   * @param {Range} [nativeRange] The browser native range instance.
+   */
+  constructor(startContainer?: Nullable<Node>, endContainer?: Nullable<Node>, startOffset?: number, endOffset?: number, startNode?: Nullable<RTENode>, endNode?: Nullable<RTENode>, nativeRange?: Range);
+  /**
+   * Returns the start container as a Node or null if it is not set.
+   * The start container could be null when the dom node should be create after re-render.
+   *
+   * @returns {Nullable<Node>} The range start element.
+   */
+  get startContainer(): Nullable<Node>;
+  /**
+   * Returns the end container as a Node or null if it is not set.
+   * The end container could be null when the dom node should be create after re-render.
+   *
+   * @returns {Nullable<Node>} The range start element.
+   */
+  get endContainer(): Nullable<Node>;
+  /**
+   * Returns the range start RTE node as a RTENode or null if it is not set.
+   * The start RTENode could be null when the range start node is the root element of the rich text editor.
+   *
+   * @returns {Nullable<RTENode>} The range start element.
+   */
+  get startNode(): Nullable<RTENode>;
+  /**
+   * Returns the range end RTE node as a RTENode or null if it is not set.
+   * The end RTENode could be null when the range end node is the root element of the rich text editor.
+   *
+   * @returns {Nullable<RTENode>} The range start element.
+   */
+  get endNode(): Nullable<RTENode>;
+  /**
+   * Returns range's start offset.
+   *
+   * @returns {number} The character length in text node or the element index of parent element.
+   */
+  get startOffset(): number;
+  /**
+   * Returns range's start offset.
+   *
+   * @returns {number} The character length in text node or the element index of parent element.
+   */
+  get endOffset(): number;
+  /**
+   * Updates the range options for a Rich Text Editor.
+   * This method will called after modify the content, the start node and end node should be rte node.
+   * This method will called after selectionchange event emit, the start node and end node should be the html node.
+   *
+   * @param {RTERangeOptions} options - An object that contains the following properties:
+   * @param {Range} [nativeRange] - The native range instance
+   * @returns {RTERange} - The new RTERange instance
+   */
+  updateRTERange(options: RTERangeOptions, nativeRange?: Range): RTERange;
+  /**
+   * Creates a Range object based on start and end nodes and offsets.
+   * Invoke this method to get the future range state if the range content modified.
+   * Invoke this method to get the native range instance if range start node and end node not defined
+   *
+   * @returns {Nullable<Range>} The range instance. The return value could be null if the start node or end node are not rendered.
+   */
+  toNativeRange(): Nullable<Range>;
+  /**
+   * Retrieves the DOM element associated with a given RTENode entity.
+   *
+   * @param {Nullable<RTENode>} node - Represents a node in a Rich Text Editor.
+   * @returns {Nullable<Node>} a Node object or null.
+   */
+  private getElementByRTENode;
+  /**
+   * Retrieves an RTENode based on the given element by checking its type and parent elements.
+   *
+   * @param {Node} element - An element in the DOM (Document Object Model).
+   * @returns { Nullable<RTENode>} Returns a nullable `RTENode` object.
+   */
+  private getRTENodeByElement;
+}