@globalpayments/vega 2.57.1 → 2.59.0

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

@@ -0,0 +1,24 @@
+import { RTETextNode } from '../../nodes/text-node';
+import { LinkGroupAnnotation } from '../../annotations/link-group-annotation';
+import { RTERenderContext } from '../../../interface';
+/**
+ * Renders link nodes and wraps them with link editor or anchor element based on edit mode.
+ */
+declare class RTELinkWrapperRenderer {
+  /**
+   * Render link nodes, grouping them by link group annotation if necessary.
+   *
+   * @param {RTETextNode[]} nodes - Array of text nodes to render.
+   * @param {LinkGroupAnnotation} linkGroupAnnotation - link group annotation
+   * @param {RTERenderContext} context - Context containing render options.
+   * @returns {HTMLElement[]} - Array of rendered HTML elements.
+   */
+  render(nodes: RTETextNode[], linkGroupAnnotation: LinkGroupAnnotation, { editable }: RTERenderContext): HTMLElement[];
+  private groupNodesByLink;
+  private isLinkGroup;
+  private renderLinkEditorWrapper;
+  private renderLink;
+  private handleChange;
+}
+declare const _default: RTELinkWrapperRenderer;
+export default _default;

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

@@ -1,9 +1,7 @@
 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;

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

@@ -1,11 +1,8 @@
 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

@@ -3,8 +3,45 @@ import { RTEImageNode } from '../../nodes/image-node';
 import { RTERenderContext } from '../../../interface';
 declare class RTEImageNodeRenderer extends RTENodeRenderer {
   render(node: RTEImageNode, renderContext: RTERenderContext): HTMLElement;
+  /**
+   * The function will render an image.
+   * In edit mode, it will be placed in the "vega-rich-text-image-editor" component as a slot.
+   * In view mode, the img image will be displayed directly.
+   *
+   * @param {ImageAnnotation} imageAnnotation - the image annotation of the image node
+   * @param {RTEImageNode} node  - the current image node
+   * @returns {HTMLElement} return a image element
+   */
   private renderImage;
   private handleChange;
+  /**
+   * Get the custom class string of the current RTEImageNode.
+   *
+   * @returns {Nullable<string>} A string of classes.
+   */
+  private getCommonClasses;
+  /**
+   * Get classes from annotations
+   *
+   * @param {RTERenderContext} [options={ standalone: false }] - Options to control style mode
+   * @returns {string} - Annotation style
+   */
+  private getClasses;
+  /**
+   * Get the class string for the image node.
+   *
+   * @param {RTEImageNode} node - The image node
+   * @param {boolean} editable - Whether the editor is in editable mode
+   * @returns {string} - The class string for the image node
+   */
+  private getClassesForImageNode;
+  /**
+   * Get the class string for the image editor.
+   *
+   * @param {RTEImageNode} node - The image node
+   * @returns {string} - The class string for the image editor
+   */
+  private getClassesForImageEditor;
 }
 declare const _default: RTEImageNodeRenderer;
 export default _default;

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

@@ -1,21 +1,8 @@
-import { AnnotationStyle, RTERenderContext } from '../../../interface';
+import { RTERenderContext } from '../../../interface';
 import { Nullable } from '../../../../../types/general';
 import { RTENode } from '../../nodes/node.abstract';
-export declare abstract class RTENodeRenderer {
+import { VegaRTEBaseRenderer } from '../base-renderer';
+export declare abstract class RTENodeRenderer extends VegaRTEBaseRenderer<RTENode, HTMLElement> {
   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 {string} - Annotation style
-   */
-  protected getClasses(node: RTENode): string;
 }

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

@@ -4,6 +4,8 @@ import { Nullable } from '../../../../../types/general';
 declare class RTETextNodeRenderer extends RTENodeRenderer {
   render(node: RTETextNode): HTMLElement;
   protected registerRef(ref: Nullable<HTMLElement>, node: RTETextNode): void;
+  private renderWithWrapper;
+  private renderText;
 }
 declare const _default: RTETextNodeRenderer;
 export default _default;

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

@@ -0,0 +1,24 @@
+import { Nullable } from '../../../../types/general';
+import { VegaRTEBaseRenderer } from './base-renderer';
+import { RTEBlock } from '../blocks/block.abstract';
+import { VNode } from '../../../../stencil-public-runtime';
+declare type BaseBlockRenderer = VegaRTEBaseRenderer<RTEBlock, HTMLElement | VNode>;
+/**
+ * RTEBlockRendererFactory is a factory class that provides methods to get the appropriate block renderer.
+ * It registers various block renderers for different types of blocks and nodes.
+ */
+declare class RTEBlockRendererFactory {
+  /**
+   * Registers the default block renderers and node renderers.
+   */
+  constructor();
+  /**
+   * getBlockRenderer retrieves the renderer for a given block type.
+   *
+   * @param {string} type - The type of the block for which the renderer is needed.
+   * @returns {Nullable<BaseBlockRenderer>} - The renderer instance if found, otherwise null.
+   */
+  getBlockRenderer(type: string): Nullable<BaseBlockRenderer>;
+}
+declare const _default: RTEBlockRendererFactory;
+export default _default;

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

@@ -0,0 +1 @@
+export {};

package/dist/types/components/vega-rich-text-editor/extensions/base-extension-renderer.d.ts

@@ -0,0 +1,61 @@
+import { RTEBlock } from '../dto/blocks/block.abstract';
+import { RTENode } from '../dto/nodes/node.abstract';
+import { VegaRTEBaseRenderer } from '../dto/renderers/base-renderer';
+import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../interface';
+declare type VegaRTEUseRef = (element: HTMLElement) => void;
+/**
+ * Base renderer for Vega Rich Text Editor.
+ */
+export declare abstract class VegaRTEExtensionRenderer extends VegaRTEBaseRenderer<RTEBlock | RTENode, VegaRTERenderResult> {
+  static REGISTER_REF_FLAG: string;
+  /**
+   * Renders the given data as a DOM element.
+   *
+   * @param {RTEBlock | RTENode} renderData - The data to render, which can be a block or a node.
+   * @param {RTERenderContext} rteContext - The rte editor context.
+   * @param {VegaRTECreateElementFunction} createElement - The function to create a DOM element.
+   * @returns {VegaRTERenderResult} - The rendered DOM element.
+   */
+  render(renderData: RTEBlock | RTENode, rteContext: RTERenderContext, createElement: VegaRTECreateElementFunction): VegaRTERenderResult;
+  /**
+   * Register the reference of the element in the rendering registry.
+   *
+   * @param {RTEBlock | RTENode} renderData - The data to register with the element.
+   * @returns {VegaRTEUseRef} - The function to register the element.
+   */
+  protected useRef(renderData: RTEBlock | RTENode): VegaRTEUseRef;
+  /**
+   * Auto render the block children if the block element is not exist
+   *
+   * @param {VegaRTERenderResult} parentElement - The parent element to append children to.
+   * @param {RTEBlock | RTENode} renderData - The data to render children for.
+   * @param {RTERenderContext} rteContext - The render context.
+   * @param {VegaRTECreateElementFunction} createElement - The function to create a DOM element.
+   */
+  private appendChildren;
+  /**
+   * Render the children node.
+   *
+   * @param {RTENode | RTEBlock} renderData - The node to render children for.
+   * @param {RTERenderContext} rteContext - The render context.
+   * @param {VegaRTECreateElementFunction} createElement - The function to create a DOM element.
+   * @returns {Nullable<VegaRTERenderResult>} - The rendered DOM element.
+   */
+  private renderChildren;
+  /**
+   * Fallback register reference for the element.
+   *
+   * @param {VegaRTERenderResult} element - The rendered DOM element.
+   * @param {RTEBlock | RTENode} renderData - The data to register with the element.
+   */
+  private fallbackRegisterRef;
+  /**
+   * Render the given data as a DOM element.
+   *
+   * @param {VegaRTECreateElementFunction} createElement - The function to create a DOM element.
+   * @param {RTEBlock | RTENode} renderData - The data to render.
+   * @param {RTERenderContext} rteContext - The render context.
+   */
+  abstract doRender(createElement: VegaRTECreateElementFunction, renderData: RTEBlock | RTENode, rteContext: RTERenderContext): VegaRTERenderResult;
+}
+export {};

package/dist/types/components/vega-rich-text-editor/extensions/base-toolbar-button-renderer.d.ts

@@ -0,0 +1,13 @@
+import { VegaRTECreateElementFunction, VegaRTEExtensionContext, VegaRTERenderResult } from '../interface';
+/**
+ * Base class for rendering extension toolbar button in the rich text editor.
+ */
+export declare abstract class VegaRTEToolbarButtonRenderer {
+  /**
+   * Renders the toolbar button.
+   *
+   * @param createElement Function to create elements in the rich text editor.
+   * @returns {VegaRTERenderResult} Toolbar button.
+   */
+  abstract render(createElement: VegaRTECreateElementFunction, editorContext?: VegaRTEExtensionContext): VegaRTERenderResult;
+}

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

@@ -3,19 +3,32 @@ import { JSXBase } from '../../stencil-public-runtime';
 import { RTEImageBlock } from './dto/blocks/image-block';
 import { RTEListItemBlock } from './dto/blocks/list-item-block';
 import { RTEListBlock } from './dto/blocks/list-block';
+import { BlockAnnotation, BlockAnnotationTypeEnum } from './dto/annotations/block-annotation.abstract';
 import { NodeAnnotation, NodeAnnotationTypeEnum } from './dto/annotations/node-annotation.abstract';
 import { InternalAnnotationTypeEnum } from './dto/annotations/annotation.abstract';
+import { CommonAnnotation, CommonAnnotationTypeEnum } from './dto/annotations/common-annotation.abstract';
 import { SelectionRangeAnnotation } from './dto/annotations/selection-range-annotation';
 import { VegaRichTextImageEditorSizeType } from './vega-rich-text-image-editor/types';
 import { RTECodeBlock } from './dto/blocks/code-block';
 import { VegaCodeBlockValue } from '../vega-code-block/types';
+import { LinkGroupAnnotation } from './dto/annotations/link-group-annotation';
+import { VNode } from '../../stencil-public-runtime';
+import * as VegaComponents from '../../components';
+import { RTEHtmlBlock } from './dto/blocks/html-block';
+import { InlineHtmlAnnotation } from './dto/annotations/inline-html-annotation';
+import type { RTERange } from './dto/range';
+import type { RTENode } from './dto/nodes/node.abstract';
 
 export type ToolbarButtonConfig = {
 	icon: string;
 	tooltip: Partial<Pick<HTMLVegaTooltipElement, 'text'>>;
+	/**
+	 * Whether to focus the content when clicked
+	 */
+	autoFocusOnClick?: boolean;
 };
 
-export type AnnotationStyle = JSXBase.HTMLAttributes['style'];
+export type AnnotationStyle = Record<string, string>;
 
 export type VegaRTETextStyleType =
 	| 'title'
@@ -28,32 +41,58 @@ export type VegaRTETextStyleType =
 	| 'heading-5'
 	| 'heading-6';
 
-export type VegaRTETextBlockType =
-	| 'title'
-	| 'subtitle'
-	| 'paragraph'
+export type RTEHeadingBlockType =
 	| 'heading-1'
 	| 'heading-2'
 	| 'heading-3'
 	| 'heading-4'
 	| 'heading-5'
-	| 'heading-6'
-	| 'list-item';
+	| 'heading-6';
 
-export type VegaRTEListBlockType = 'bullet-list' | 'number-list';
+export type VegaRTETextBlockType = 'title' | 'subtitle' | 'paragraph' | RTEHeadingBlockType | 'list-item';
 
-export type RTEBlockType = VegaRTETextBlockType | VegaRTEListBlockType | 'image' | 'code-block';
+export type VegaRTEListBlockType = 'bullet-list' | 'number-list';
 
-export type RTEContentBlock = RTETextBlock | RTEImageBlock | RTEListBlock | RTEListItemBlock | RTECodeBlock;
+export type RTEBlockType =
+	| VegaRTETextBlockType
+	| VegaRTEListBlockType
+	| 'image'
+	| 'code-block'
+	| 'html-block';
+
+export type RTEContentBlock =
+	| RTETextBlock
+	| RTEImageBlock
+	| RTEListBlock
+	| RTEListItemBlock
+	| RTECodeBlock
+	| RTEHtmlBlock;
+
+export type VegaRTEAnnotations =
+	| VegaRTEBlockAnnotations
+	| VegaRTETextAnnotations
+	| VegaRTEImageAnnotations
+	| VegaRTETextBlockAnnotations;
 
 export type VegaRTEBlockAnnotations = {
 	textAlign?: VegaRTEBlockAlignment;
 	indent?: number;
+	customAttribute?: Record<string, string>;
+	customClass?: string[];
+	customStyle?: AnnotationStyle;
+	internalWrapper?: boolean;
 };
 
-export type ListType = 'bullet-list' | 'number-list';
+export type ListType = VegaRTEListBlockType;
 
-export type VegaRTELink = { href: string; groupKey: string };
+//TODO: href should include to customAttribute.
+export type VegaRTELink = {
+	href: string;
+	groupKey: string;
+	customAttribute?: Record<string, string>;
+	customClass?: string[];
+	customStyle?: AnnotationStyle;
+};
 
 export type VegaRTETextAnnotations = {
 	bold?: boolean;
@@ -62,39 +101,34 @@ export type VegaRTETextAnnotations = {
 	strikethrough?: boolean;
 	textColor?: string;
 	link?: VegaRTELink;
-	code?: never;
+	code?: boolean;
+	customAttribute?: Record<string, string>;
+	customClass?: string[];
+	customStyle?: AnnotationStyle;
+	inlineHtml?: VegaInlineHtmlSchema;
+	plainText?: boolean;
 };
 
 export type VegaRTEImageAnnotations = {
 	size?: VegaRichTextImageEditorSizeType;
 	alt?: string;
+	customAttribute?: Record<string, string>;
+	customClass?: string[];
+	customStyle?: AnnotationStyle;
 };
 
-export type VegaRTECodeAnnotations = {
-	code: boolean;
-	bold?: never;
-	italic?: never;
-	underline?: never;
-	strikethrough?: never;
-	color?: never;
-	link?: never;
+export type VegaRTETextBlockAnnotations = VegaRTEBlockAnnotations & {
+	textStyle?: VegaRTETextStyleType;
 };
 
-export type VegaRTEBaseNode = { id: string; type: 'text' | 'image' };
+export type VegaRTEBaseNode = { id: string; type: string };
 
 export type VegaRTEText = {
-	type: 'text';
 	text: string;
 	annotations?: VegaRTETextAnnotations;
 };
 
-export type VegaRTECode = {
-	type: 'text';
-	text: string;
-	annotations?: VegaRTECodeAnnotations;
-};
-
-export type VegaRTETextNode = VegaRTEBaseNode & (VegaRTEText | VegaRTECode);
+export type VegaRTETextNode = VegaRTEBaseNode & VegaRTEText;
 
 export type VegaRTEImageNode = {
 	id: string;
@@ -105,11 +139,9 @@ export type VegaRTEImageNode = {
 
 export type VegaRTEBlockAlignment = 'left' | 'center' | 'right' | 'justify';
 
-export type VegaRTEImageBlock = {
-	id: string;
+export type VegaRTEImageBlock = VegaRTEBlockBase & {
 	type: 'image';
 	nodes: VegaRTEImageNode[];
-	annotations?: VegaRTEBlockAnnotations;
 };
 
 export interface VegaRTEBlockBase {
@@ -120,9 +152,7 @@ export interface VegaRTEBlockBase {
 export interface VegaRTETextBlock extends VegaRTEBlockBase {
 	type: VegaRTETextBlockType;
 	nodes: VegaRTETextNode[];
-	annotations?: VegaRTEBlockAnnotations & {
-		textStyle?: VegaRTETextStyleType;
-	};
+	annotations?: VegaRTETextBlockAnnotations;
 }
 
 export type VegaRTEListItemBlock = VegaRTETextBlock & {
@@ -141,12 +171,22 @@ export type VegaRTECodeBlock = VegaRTEBlockBase & {
 	language?: VegaCodeBlockValue['language'];
 };
 
+export type VegaRTEHtmlBlock = VegaRTEBlockBase & {
+	type: 'html-block';
+	htmlTag: string;
+	children: VegaRTEContentBlock[];
+};
+
+export type VegaRTEContentNode = VegaRTETextNode | VegaRTEImageNode;
+
 export type VegaRTEContentBlock =
 	| VegaRTETextBlock
 	| VegaRTEImageBlock
 	| VegaRTEListBlock
 	| VegaRTEListItemBlock
-	| VegaRTECodeBlock;
+	| VegaRTECodeBlock
+	| VegaRTECustomBlock
+	| VegaRTEHtmlBlock;
 
 export type VegaRTEToolbarItem =
 	| 'clearStyle'
@@ -169,7 +209,8 @@ export type VegaRTEToolbarItem =
 	| 'centerAlign'
 	| 'rightAlign'
 	| 'justified'
-	| 'codeBlock';
+	| 'codeBlock'
+	| string; // Custom toolbar item types can be added here
 
 export type VegaRTEColorSchema = {
 	key: string;
@@ -177,16 +218,105 @@ export type VegaRTEColorSchema = {
 	dark: string;
 };
 
+export type RTEBlockAnnotationMapKey =
+	| keyof typeof BlockAnnotationTypeEnum
+	| InternalAnnotationTypeEnum.LINK_GROUP
+	| keyof typeof CommonAnnotationTypeEnum;
+
+export type RTEBlockAnnotationMapValue = BlockAnnotation | LinkGroupAnnotation | CommonAnnotation;
+
 export type RTENodeAnnotationMapKey =
 	| keyof typeof NodeAnnotationTypeEnum
-	| keyof typeof InternalAnnotationTypeEnum;
+	| keyof typeof InternalAnnotationTypeEnum
+	| keyof typeof CommonAnnotationTypeEnum;
 
-export type RTENodeAnnotationMapValue = NodeAnnotation | SelectionRangeAnnotation;
+export type RTENodeAnnotationMapValue =
+	| NodeAnnotation
+	| SelectionRangeAnnotation
+	| CommonAnnotation
+	| InlineHtmlAnnotation;
 
 export type VegaRichTextEditorImage = { file: File; sendBackUploadedURLCallback: (url: string) => void };
 
-export type RTERenderContext = { editable?: boolean };
+export type RTERenderContext = {
+	editable?: boolean;
+	/**
+	 * If `true`, render using inline styles for standalone web pages.
+	 * If `false`, use CSS classes for integration within the RTE content view.
+	 */
+	standalone?: boolean;
+} & Partial<Pick<VegaRTETransformOptions, 'autoMatchFormat'>>;
 
 export type HeadingLevel = 1 | 2 | 3;
 
-type RTEBlockWithNodes = RTETextBlock | RTEImageBlock | RTECodeBlock;
+export type RTERenderCustomAttributes = {
+	filterAttributes?: string[];
+};
+
+export type VegaRTETransformOptions = {
+	/**
+	 * If `true`, automatically match the format of the content to the RTE's internal format.
+	 */
+	autoMatchFormat?: boolean;
+	/**
+	 * If `true`, skip custom style, class and attribute when generating annotations from HTML elements.
+	 */
+	skipCustomAnnotations?: boolean;
+};
+
+export type VegaRTESourceEditConfig = Partial<Pick<VegaRTETransformOptions, 'autoMatchFormat'>> & {
+	// Other configurations can be added here as needed
+};
+
+export type VegaRTETokenNode = VegaRTETextNode & {
+	type: string;
+	token: string;
+};
+
+export type VegaRTERenderResult = VNode;
+
+export type VegaRTECustomElementAction = {
+	type: 'selected' | 'unSelected' | 'delete' | 'insertText';
+};
+
+export type VegaRTECustomBlock = VegaRTEBlockBase & {
+	type: string;
+	children: VegaRTECustomNode[];
+};
+
+export type VegaRTECustomNode = VegaRTEBaseNode & {
+	[key: string]: unknown;
+};
+
+export type VegaRTERenderNode = VegaRTERenderResult | string | number;
+
+export type VegaRTECreateElementFunction = <
+	T extends keyof VegaComponents.JSX.IntrinsicElements | keyof JSXBase.IntrinsicElements,
+>(
+	elementType: T,
+	props?: T extends keyof VegaComponents.JSX.IntrinsicElements
+		? VegaComponents.JSX.IntrinsicElements[T] | { [attrName: string]: unknown }
+		: T extends keyof JSXBase.IntrinsicElements
+		? JSXBase.IntrinsicElements[T] | { [attrName: string]: unknown }
+		: null,
+	children?: VegaRTERenderNode | VegaRTERenderNode[],
+) => VegaRTERenderResult;
+
+export type VegaRTEExtensionContext = {
+	host: HTMLVegaRichTextEditorElement;
+	rteRange: RTERange;
+	sourceEditMode: boolean;
+};
+
+export type VegaInlineHtmlSchema = {
+	htmlTag: string;
+	child?: VegaInlineHtmlSchema;
+	customAttribute?: Record<string, string>;
+	customClass?: string[];
+	customStyle?: Record<string, string>;
+};
+
+export type FocusNodeRangeState = {
+	startNode: RTENode;
+	startOffset: number;
+};

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

@@ -54,4 +54,23 @@ export declare class DeleteSelectedNodesController extends VegaSlimmer {
    * @returns {boolean} true or false
    */
   private shouldMergeTextNode;
+  /**
+   * Check the decorator node is fully in the range end.
+   *
+   * @param {RTENode} rangeEndNode - The end node of the range
+   * @param {number} endOffset - The end offset of the range
+   * @param {RTENode<RTEBlock>} checkedNode - The checked decorator node
+   * @returns {boolean} - Whether the end node is fully within the range
+   */
+  private isEndNodeFullyInTheRange;
+  /**
+   * Check if the start decorator node is fully in the range.
+   *
+   * @param {RTENode<RTEBlock>} rangeStartNode - The start node of the range
+   * @param {RTENode} rangeEndNode - The end node of the range
+   * @param {number} startOffset - The start offset of the range
+   * @param {number} endOffset - The end offset of the range
+   * @returns {boolean} - Whether the start node is fully within the range
+   */
+  private isStartNodeFullyInTheRange;
 }

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

@@ -28,6 +28,7 @@ export declare class FocusController extends VegaSlimmer {
    * Move the caret to the end of the node
    *
    * @param {Node} targetNode - The node to move the caret to
+   * @param {number} offset - The offset to move the caret to
    */
   private setCaretRangeToNodeEnd;
 }

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/annotation-generator-strategy.abstract.d.ts

@@ -0,0 +1,16 @@
+import { VegaRTEAnnotations } from '../../../../../interface';
+import { HtmlElementToAnnotationGenerateOptions, RTEDtoClassPrototype } from './html-element-to-annotation-generator';
+/**
+ * Abstract class to define handler for generate the annotations
+ */
+export declare abstract class AnnotationGeneratorStrategyAbstract {
+  /**
+   * Determines if the handler can process the given DTO.
+   *
+   * @param {RTEDtoClassPrototype} targetDTO - Target DTO.
+   * @param {HtmlElementToAnnotationGenerateOptions} [options] - Options for annotation generator.
+   * @returns {boolean} - True if the strategy can handle the DTO, otherwise false.
+   */
+  abstract canHandle<T extends RTEDtoClassPrototype>(targetDTO: T, options: HtmlElementToAnnotationGenerateOptions): boolean;
+  abstract handle(element: HTMLElement, parentAnnotations?: VegaRTEAnnotations): VegaRTEAnnotations;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/bold-annotaion-handler.d.ts

@@ -0,0 +1,25 @@
+import { VegaRTETextAnnotations } from '../../../../../interface';
+import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { RTEDtoClassPrototype } from './html-element-to-annotation-generator';
+/** Handle bold annotation */
+export declare class BoldAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T): boolean;
+  /**
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
+   * @returns {VegaRTETextAnnotations} - Annotation.
+   */
+  handle(element: HTMLElement, parentAnnotations?: VegaRTETextAnnotations): VegaRTETextAnnotations;
+  /**
+   * Is bold element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {boolean} - boolean.
+   */
+  private isBold;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/code-annotation-handler.d.ts

@@ -0,0 +1,25 @@
+import { VegaRTETextAnnotations } from '../../../../../interface';
+import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { RTEDtoClassPrototype } from './html-element-to-annotation-generator';
+/** Handle code annotation */
+export declare class CodeAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T): boolean;
+  /**
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
+   * @returns {VegaRTETextAnnotations} - Annotation.
+   */
+  handle(element: HTMLElement, parentAnnotations?: VegaRTETextAnnotations): VegaRTETextAnnotations;
+  /**
+   * Is code element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {boolean} - boolean.
+   */
+  private isCode;
+}