@globalpayments/vega 2.32.0 → 2.34.0

package/dist/types/components/vega-rich-text-editor/dto/annotations/text-color-annotation.d.ts

@@ -0,0 +1,50 @@
+import { NodeAnnotation, NodeAnnotationTypeEnum } from './node-annotation.abstract';
+import { Nullable } from '../../../../types/general';
+import { AnnotationStyle, VegaRTEColorSchema } from '../../interface';
+/**
+ * Annotation to make text with text color
+ */
+export declare class TextColorAnnotation extends NodeAnnotation {
+  readonly type: NodeAnnotationTypeEnum;
+  textColor: VegaRTEColorSchema;
+  constructor(textColor: string);
+  /**
+   * Generate the map item for the annotation
+   *
+   * @param {string} textColor - text color annotation
+   * @returns {[NodeAnnotationTypeEnum.TEXT_COLOR, TextColorAnnotation]} Map item for the annotation
+   */
+  static from(textColor: string): [NodeAnnotationTypeEnum.TEXT_COLOR, TextColorAnnotation];
+  /**
+   * 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: HTMLElement): Nullable<[NodeAnnotationTypeEnum.TEXT_COLOR, TextColorAnnotation]>;
+  /**
+   * Generate the JSON representation of the annotation
+   *
+   * @returns {Record<string, unknown>} JSON representation of the annotation
+   */
+  toJSON(): Record<string, unknown>;
+  /**
+   * Generate the class for the annotation
+   *
+   * @returns {Nullable<string>} - Annotation class
+   */
+  renderClass(): Nullable<string>;
+  /**
+   * Generate the style for the annotation
+   *
+   * @returns {Nullable<AnnotationStyle>} - Annotation style
+   */
+  render(): Nullable<AnnotationStyle>;
+  /**
+   * format text color
+   *
+   * @param {string} textColor - text color
+   * @returns {VegaRTEColorSchema} - VegaRTEColorSchema
+   */
+  private formatTextColor;
+}

package/dist/types/components/vega-rich-text-editor/dto/annotations/text-style-annotation.d.ts

@@ -0,0 +1,44 @@
+import { BlockAnnotation, BlockAnnotationTypeEnum } from './block-annotation.abstract';
+import { AnnotationStyle, VegaRTETextStyleType } from '../../interface';
+import { Nullable } from '../../../../types/general';
+/**
+ * Text style annotation
+ */
+export declare class TextStyleAnnotation extends BlockAnnotation {
+  readonly type: BlockAnnotationTypeEnum;
+  textStyle: VegaRTETextStyleType;
+  constructor(textStyle: VegaRTETextStyleType);
+  /**
+   * Generate the map item for the annotations
+   *
+   * @param {VegaRTETextStyleType} textStyle - the text style type
+   * @returns {[BlockAnnotationTypeEnum.TEXT_STYLE, TextStyleAnnotation]} Map item for the annotation
+   */
+  static from(textStyle: VegaRTETextStyleType): [BlockAnnotationTypeEnum.TEXT_STYLE, TextStyleAnnotation];
+  /**
+   * 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: HTMLElement): [BlockAnnotationTypeEnum.TEXT_STYLE, TextStyleAnnotation];
+  /**
+   * Get the type of block.
+   *
+   * @param {HTMLElement} node - An HTMLElement.
+   * @returns {VegaRTETextStyleType} text style type.
+   */
+  private static getTextStyle;
+  /**
+   * Generate the JSON representation of the annotation
+   *
+   * @returns {Nullable<Record<string, unknown>>} JSON representation of the annotation
+   */
+  toJSON(): Nullable<Record<string, unknown>>;
+  /**
+   * Render the styles by block type
+   *
+   * @returns {AnnotationStyle} the styles to apply
+   */
+  render(): AnnotationStyle;
+}

package/dist/types/components/vega-rich-text-editor/dto/annotations/underline-annotation.d.ts

@@ -0,0 +1,43 @@
+import { NodeAnnotation, NodeAnnotationTypeEnum } from './node-annotation.abstract';
+import { Nullable } from '../../../../types/general';
+import { AnnotationStyle } from '../../interface';
+/**
+ * Annotation to make text with underline
+ */
+export declare class UnderlineAnnotation extends NodeAnnotation {
+  readonly type: NodeAnnotationTypeEnum;
+  underline: boolean;
+  constructor(underline: boolean);
+  /**
+   * Generate the map item for the annotation
+   *
+   * @param {boolean} underline - Underline annotation
+   * @returns {[NodeAnnotationTypeEnum.UNDERLINE, UnderlineAnnotation]} Map item for the annotation
+   */
+  static from(underline: boolean): [NodeAnnotationTypeEnum.UNDERLINE, UnderlineAnnotation];
+  /**
+   * 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: HTMLElement): [NodeAnnotationTypeEnum.UNDERLINE, UnderlineAnnotation];
+  /**
+   * Generate the JSON representation of the annotation
+   *
+   * @returns {Record<string, unknown>} JSON representation of the annotation
+   */
+  toJSON(): Record<string, unknown>;
+  /**
+   * Generate the class for the annotation
+   *
+   * @returns {Nullable<string>} - Annotation class
+   */
+  renderClass(): Nullable<string>;
+  /**
+   * Generate the style for the annotation
+   *
+   * @returns {Nullable<AnnotationStyle>} - Annotation style
+   */
+  render(): Nullable<AnnotationStyle>;
+}

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

@@ -0,0 +1,175 @@
+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]>;
+  /**
+   * Create annotations for block element.
+   *
+   * @param {string} type - Annotations type.
+   * @param {HTMLElement} node - current node.
+   * @returns {Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>} - result.
+   */
+  protected static createAnnotationEntityFromHTML(type: string, node: HTMLElement): 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,49 @@
+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;
+  static fromHTML(node: HTMLImageElement | HTMLDivElement): 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,30 @@
+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;
+  static fromHTML(node: HTMLUListElement | HTMLOListElement): 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,33 @@
+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;
+  static fromHTML(node: HTMLLIElement): 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,63 @@
+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;
+  static fromHTML(node: HTMLElement, blockType: VegaRTETextBlockType): 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,19 @@
+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;
+  static fromHTML(node: HTMLImageElement | HTMLVegaRichTextImageEditorElement, 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;
+}