@globalpayments/vega 2.57.1 → 2.59.0

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

@@ -1,26 +1,28 @@
-import { VegaRTETextBlock, VegaRTETextBlockType, VegaRTEBlockAnnotations, VegaRTETextStyleType } from '../../interface';
+import { VegaRTETextBlock, VegaRTETextBlockType, VegaRTEBlockAnnotations, VegaRTETextStyleType, VegaRTETransformOptions } from '../../interface';
 import { RTETextNode } from '../nodes/text-node';
 import { Nullable } from '../../../../types/general';
-import { BlockAnnotation, BlockAnnotationTypeEnum } from '../annotations/block-annotation.abstract';
 import { VegaRTEContent } from '../content-state';
-import { RTEBlock } from './block.abstract';
+import { BlockAnnotationsEntity, RTEBlock } from './block.abstract';
 import { AnnotationAction } from '../actions/annotation-action.abstract';
 import { RTEListBlock } from './list-block';
+import type { RTEHtmlBlock } from './html-block';
+export declare type RTETextBlockTagType = 'div' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'p';
 /**
  * Text block
  */
-export declare class RTETextBlock extends RTEBlock<VegaRTEContent | RTEListBlock, RTETextNode> {
+export declare class RTETextBlock extends RTEBlock<VegaRTEContent | RTEListBlock | RTEHtmlBlock, RTETextNode> {
   type: VegaRTETextBlockType;
   children: RTETextNode[];
-  parent: VegaRTEContent | RTEListBlock;
-  constructor(id: string, type: VegaRTETextBlockType);
+  parent: VegaRTEContent | RTEListBlock | RTEHtmlBlock;
+  constructor(id: string, type: VegaRTETextBlockType, options?: VegaRTETransformOptions);
   /**
    * Converts a VegaRTETextBlock into an RTETextBlock.
    *
    * @param {VegaRTETextBlock} block - The block object
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
    * @returns {RTETextBlock} A RTETextBlock class
    */
-  static from(block: VegaRTETextBlock): RTETextBlock;
+  static from(block: VegaRTETextBlock, options?: VegaRTETransformOptions): RTETextBlock;
   /**
    * The function `createAnnotationEntity` creates a block annotation entity based on the provided type
    * and value.
@@ -30,10 +32,10 @@ export declare class RTETextBlock extends RTEBlock<VegaRTEContent | RTEListBlock
    * @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
+   * @returns {Nullable<BlockAnnotationsEntity>} 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 createAnnotationEntity(type: keyof VegaRTEBlockAnnotations | 'textStyle', value: unknown): Nullable<BlockAnnotationsEntity>;
   /**
    * Checks if a given text block type is one of the acceptable text styles.
    *
@@ -51,13 +53,17 @@ export declare class RTETextBlock extends RTEBlock<VegaRTEContent | RTEListBlock
    * @inheritDoc
    */
   toJSON(): VegaRTETextBlock;
+  /**
+   * @inheritDoc
+   */
+  toHtml(options?: VegaRTETransformOptions): string;
   /**
    * Clone the nodes to a new block
    *
    * @param {RTEBlock} nodes - The nodes will be copied
-   * @returns {RTEBlock} New block
+   * @returns {RTETextBlock} New block
    */
-  cloneWithNodes(nodes: RTETextNode[]): RTEBlock;
+  cloneWithNodes(nodes: RTETextNode[]): RTETextBlock;
   /**
    * @inheritDoc
    */
@@ -71,13 +77,22 @@ export declare class RTETextBlock extends RTEBlock<VegaRTEContent | RTEListBlock
    */
   getLastNode(): RTETextNode;
   /**
-   * Create new empty paragraph.
+   * Get the HTML tag for the block based on its type.
    *
-   * @returns {RTETextBlock} Paragraph.
+   * @returns {RTETextBlockTagType} The HTML tag for the block.
    */
-  createNewParagraph(): RTETextBlock;
+  getBlockTag(): RTETextBlockTagType;
   /**
    * @inheritDoc
    */
   protected doAnnotationActionApply(action: AnnotationAction): void;
+  /**
+   * Generate Link Html
+   *
+   * @param {LinkGroupAnnotation} linkGroupAnnotation - linkGroupAnnotation
+   * @param {string} nodesHtml - The nodes html
+   * @param {VegaRTETransformOptions} options - options
+   * @returns {string} link html
+   */
+  private generateLinkHtml;
 }

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

@@ -1,10 +1,11 @@
-import { RTEContentBlock, VegaRTEContentBlock, ListType } from '../interface';
+import { RTEContentBlock, VegaRTEContentBlock, ListType, VegaRTETransformOptions } from '../interface';
 import { RTEListBlock } from './blocks/list-block';
-import { RTETextBlock } from './blocks/text-block';
+import type { RTETextBlock } from './blocks/text-block';
 import { ModifyContentAction } from './actions/modify-content-action.abstract';
 import { RTEListItemBlock } from './blocks/list-item-block';
 import { RTENode } from './nodes/node.abstract';
 import { Nullable } from '../../../types/general';
+import './setup';
 /**
  * Class representing the content state of the rich text editor.
  */
@@ -15,15 +16,24 @@ export declare class VegaRTEContent {
    * Converts a JSON array of blocks to a class array of RTEContentBlock.
    *
    * @param {VegaRTEContentBlock[]} value The JSON array of blocks to convert.
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
    * @returns {VegaRTEContent} The converted array of RTEContentBlock.
    */
-  static fromJSON(value: VegaRTEContentBlock[]): VegaRTEContent;
+  static fromJSON(value: VegaRTEContentBlock[], options?: VegaRTETransformOptions): VegaRTEContent;
   /**
    * Create an empty content state
    *
    * @returns {VegaRTEContent} An empty content state
    */
   static createEmptyContent(): VegaRTEContent;
+  /**
+   * Converts HTML content to a VegaRTEContent instance.
+   *
+   * @param {string} html - The HTML string to convert.
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
+   * @returns {VegaRTEContent} The converted content state.
+   */
+  static fromHtml(html: string, options?: VegaRTETransformOptions): VegaRTEContent;
   /**
    * Clones the content state.
    *
@@ -37,6 +47,13 @@ export declare class VegaRTEContent {
    * @returns {VegaRTEContentBlock[]} The JSON array of blocks.
    */
   toJSON(): VegaRTEContentBlock[];
+  /**
+   * Converts the content state to HTML.
+   *
+   * @param {VegaRTETransformOptions} [options] - Optional rendering context for the content.
+   * @returns {string} The HTML representation of the content state.
+   */
+  toHtml(options?: VegaRTETransformOptions): string;
   /**
    * Internal method to add the block item, remove the block item
    *

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

@@ -2,9 +2,10 @@ import { VegaRTEBaseNode, VegaRTECodeBlock } from '../../interface';
 import { AnnotationAction } from '../actions/annotation-action.abstract';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 import { RTECodeBlock } from '../blocks/code-block';
-import { NodeTypeEnum, RTENode } from './node.abstract';
+import { NodeTypeEnum } from './node.abstract';
 import { InternalAnnotationTypeEnum } from '../annotations/annotation.abstract';
 import { SelectionRangeAnnotation } from '../annotations/selection-range-annotation';
+import { RTEDecoratorNode } from './decorator-node';
 declare type VegaRTECodeNode = VegaRTEBaseNode & {
   text: string;
   language?: VegaRTECodeBlock['language'];
@@ -12,7 +13,7 @@ declare type VegaRTECodeNode = VegaRTEBaseNode & {
 /**
  * RTE code node DTO class.
  */
-export declare class RTECodeBlockNode extends RTENode<RTECodeBlock> {
+export declare class RTECodeBlockNode extends RTEDecoratorNode<RTECodeBlock> {
   type: NodeTypeEnum;
   parent: RTECodeBlock;
   text: string;
@@ -25,6 +26,10 @@ export declare class RTECodeBlockNode extends RTENode<RTECodeBlock> {
    * @returns {VegaRTECodeNode} - An object contains content property.
    */
   toJSON(): VegaRTECodeNode;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
   /**
    * @inheritDoc
    */

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

@@ -0,0 +1,41 @@
+import { Nullable } from '../../../../types/general';
+import { RTEBlock } from '../blocks/block.abstract';
+import { RTENode } from './node.abstract';
+/**
+ * Abstract class for decorator nodes. A decorator node modifies content like an image node that will delete the whole node when the delete button is pressed.
+ */
+export declare abstract class RTEDecoratorNode<P extends RTEBlock = RTEBlock> extends RTENode<P> {
+  static DECORATOR_CONTAINER_CLASS: string;
+  static DECORATOR_NODE_CLASS: string;
+  type: string;
+  parent: P;
+  isSelected: boolean;
+  /**
+   * Check the element is a decorator node container.
+   *
+   * @param {HTMLElement} element - The checked element.
+   * @returns {boolean} - The result of the check.
+   */
+  static isDecoratorNodeContainerElement(element: HTMLElement): boolean;
+  /**
+   * Get the decorator node element within the container.
+   *
+   * @param {HTMLElement} container - The container element.
+   * @returns {Nullable<HTMLElement>} - The decorator node element, if found.
+   */
+  static getDecoratorNodeElement(container: HTMLElement): Nullable<HTMLElement>;
+  /**
+   * @inheritDoc
+   */
+  getRangeEndOffset(): number;
+  /**
+   * @inheritDoc
+   */
+  getRangeContainer(): Nullable<Node>;
+  /**
+   * The decorator node is not content editable from the outside.
+   *
+   * @returns {boolean} - Always returns false for decorator nodes.
+   */
+  isContentEditable(): boolean;
+}

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

@@ -1,12 +1,13 @@
-import { NodeTypeEnum, RTENode } from './node.abstract';
+import { NodeTypeEnum } from './node.abstract';
 import { RTEImageBlock } from '../blocks/image-block';
-import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTEImageNode } from '../../interface';
+import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTETransformOptions, VegaRTEImageNode } from '../../interface';
 import { ImageAnnotationAction } from '../actions/image-annotation-action';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
+import { RTEDecoratorNode } from './decorator-node';
 /**
  * Image node
  */
-export declare class RTEImageNode extends RTENode<RTEImageBlock> {
+export declare class RTEImageNode extends RTEDecoratorNode<RTEImageBlock> {
   readonly type: NodeTypeEnum;
   parent: RTEImageBlock;
   url: string;
@@ -16,9 +17,10 @@ export declare class RTEImageNode extends RTENode<RTEImageBlock> {
    *
    * @param {VegaRTEImageNode} node - The node to be converted.
    * @param {RTEImageBlock} parentBlock - The parent block
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
    * @returns {RTEImageNode} An instance of `RTEImageBlock`
    */
-  static from(node: VegaRTEImageNode, parentBlock: RTEImageBlock): RTEImageNode;
+  static from(node: VegaRTEImageNode, parentBlock: RTEImageBlock, options?: VegaRTETransformOptions): RTEImageNode;
   /**
    * @inheritDoc
    */
@@ -27,6 +29,10 @@ export declare class RTEImageNode extends RTENode<RTEImageBlock> {
    * @inheritDoc
    */
   clone(): RTEImageNode;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
   /**
    * @inheritDoc
    */

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

@@ -1,8 +1,11 @@
-import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTEBaseNode } from '../../interface';
+import { AnnotationStyle, RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, RTERenderContext, VegaRTEImageAnnotations, VegaRTETextAnnotations, VegaRTETransformOptions } 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';
+import { CustomAttributeAnnotation } from '../annotations/custom-attribute-annotation';
+import { ClassType } from '../../../../types/class.type';
+import type { RTETextNode } from './text-node';
 export declare enum NodeTypeEnum {
   TEXT = "TEXT",
   IMAGE = "IMAGE",
@@ -15,9 +18,26 @@ export declare type NodeAnnotations = Map<RTENodeAnnotationMapKey, RTENodeAnnota
 export declare abstract class RTENode<P extends RTEBlock = RTEBlock> {
   id: string;
   annotationMap: NodeAnnotations;
-  abstract readonly type: NodeTypeEnum;
+  abstract readonly type: string;
   abstract parent: P;
   protected constructor(id: string, annotationMap?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
+  /**
+   * Creates a new instance of the RTENode from the given JSON data.
+   *
+   * @param {unknown} json - The JSON data to create the node from.
+   * @param {RTEBlock} parentBlock - The parent block of the node.
+   * @param {VegaRTETransformOptions} options - Options for transforming the node.
+   */
+  static from(json: unknown, parentBlock: RTEBlock, options?: VegaRTETransformOptions): InstanceType<ClassType<RTENode>>;
+  /**
+   * 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.
+   */
+  protected static createAnnotationEntity(type: keyof VegaRTETextAnnotations | keyof VegaRTEImageAnnotations, value: unknown): Nullable<[RTENodeAnnotationMapKey, RTENodeAnnotationMapValue]>;
   /**
    * Get annotation by type
    *
@@ -39,6 +59,39 @@ export declare abstract class RTENode<P extends RTEBlock = RTEBlock> {
    * @returns {this} - Node
    */
   apply(action: AnnotationAction | ModifyContentAction): this;
+  /**
+   * Get styles from annotations
+   *
+   * @param {RTERenderContext} [options={ standalone: false }] - Options to control style mode
+   * @returns {AnnotationStyle} - Annotation styles
+   */
+  getStyles(options?: RTERenderContext): AnnotationStyle;
+  /**
+   * Get classes from annotations
+   *
+   * @param {RTERenderContext} [options={ standalone: false }] - Options to control style mode
+   * @returns {string} - Annotation style
+   */
+  getClasses(options?: RTERenderContext): string;
+  /**
+   * Get custom attribute annotation, excluding "class" and "style"
+   *
+   * @returns {CustomAttributeAnnotation} - custom attribute annotation
+   */
+  getCustomAttributesAnnotation(): CustomAttributeAnnotation;
+  /**
+   * Check if the node is a text node.
+   *
+   * @returns {boolean} - True if the node is a text node, false otherwise.
+   */
+  isTextNode(): this is RTETextNode;
+  /**
+   * Generate attributes as string
+   *
+   * @param {...string} attrs - Additional attributes to include
+   * @returns {string} - Attributes as string
+   */
+  protected generateAttributeString(...attrs: string[]): string;
   /**
    * apply annotation action or modify content action
    *
@@ -55,8 +108,66 @@ export declare abstract class RTENode<P extends RTEBlock = RTEBlock> {
    * @returns {NodeAnnotations} A new Map containing cloned annotations.
    */
   protected cloneAnnotations(): NodeAnnotations;
-  abstract toJSON(): VegaRTEBaseNode;
+  /**
+   * Placeholder for the method to be implemented in sub classes.
+   *
+   * @param {AnnotationAction} action Annotation action
+   */
+  protected doAnnotationActionApply(action: AnnotationAction): void;
+  /**
+   * Placeholder for the method to be implemented in sub classes.
+   *
+   * @param {ModifyContentAction} action ModifyContentAction
+   */
+  protected doModifyActionApply(action: ModifyContentAction): void;
+  /**
+   * Merge an array of annotation styles into a single style object.
+   * e.g.,
+   * { textDecoration: 'underline', textDecoration: 'line-through' }
+   * -> { textDecoration: 'underline line-through' }
+   *
+   * @param {AnnotationStyle[]} styles - Array of annotation style objects to merge.
+   * @param {string[]} canMergeKeyList - List of style keys that can be merged by concatenation.
+   * @returns {AnnotationStyle} - The merged annotation style object.
+   */
+  private mergeAnnotationStyles;
+  /**
+   * Clone the node.
+   *
+   * @returns {InstanceType<ClassType<RTENode>>} A new instance of the node with cloned properties.
+   */
   abstract clone(): RTENode<P>;
-  protected abstract doAnnotationActionApply(action: AnnotationAction): void;
-  protected abstract doModifyActionApply(action: ModifyContentAction): void;
+  /**
+   * Convert the node to HTML.
+   *
+   * @returns {string} The HTML string representing the node.
+   */
+  abstract toHtml(): string;
+  /**
+   * Convert the node to a JSON object.
+   *
+   * @returns {unknown} The JSON representation of the node.
+   */
+  abstract toJSON(): unknown;
+  /**
+   * The range offset value when the cursor position at the end of the node content.
+   *
+   * @example For text node, it is the length of the text content.
+   * @example For none-editable text node, it is the (index + 1) of the token in the parent children.
+   * @example For image node, it is always 1.
+   * @returns {number} - The end offset of the node.
+   */
+  abstract getRangeEndOffset(): number;
+  /**
+   * The container element when the cursor position at the start of the node content.
+   *
+   * @returns {Nullable<Node>} - The start container Node of the node.
+   */
+  abstract getRangeContainer(): Nullable<Node>;
+  /**
+   * Check if the node is a content editable node.
+   *
+   * @returns {boolean} - True if the node is content editable, false otherwise.
+   */
+  abstract isContentEditable(): boolean;
 }

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

@@ -1,6 +1,7 @@
-import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTETextNode } from '../../interface';
+import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTETransformOptions, VegaRTETextAnnotations, VegaRTETextNode } from '../../interface';
 import { NodeTypeEnum, RTENode } from './node.abstract';
 import { AnnotationAction } from '../actions/annotation-action.abstract';
+import { Nullable } from '../../../../types/general';
 import { RTETextBlock } from '../blocks/text-block';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 export declare type Link = {
@@ -10,31 +11,46 @@ export declare type Link = {
  * Text node
  */
 export declare class RTETextNode extends RTENode<RTETextBlock> {
-  readonly type: NodeTypeEnum;
+  static registerActionStrategyStatus: Record<string, boolean>;
+  static readonly htmlTag: 'span';
+  readonly type: NodeTypeEnum | string;
   text: string;
   parent: RTETextBlock;
   constructor(id: string, text: string, parentBlock: RTETextBlock, annotationMap?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
+  /**
+   * Determines if the given HTML tag is supported by the RTETextNode.
+   *
+   * @param {string} tag - The HTML tag to check.
+   * @returns {boolean} `true` if the tag is supported, otherwise `false`.
+   */
+  static supportsHtmlTag(tag: string): boolean;
   /**
    * Creates an RTETextNode from a VegaRTETextNode with annotations and a parent RTETextBlock.
    *
    * @param {VegaRTETextNode} richText - A rich text node
    * @param {RTETextBlock} parentBlock - Parent block
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
    * @returns {RTETextNode} an RTETextNode
    */
-  static from(richText: VegaRTETextNode, parentBlock: RTETextBlock): RTETextNode;
+  static from(richText: VegaRTETextNode, parentBlock: RTETextBlock, options?: VegaRTETransformOptions): 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.
+   * @param {VegaRTETransformOptions} [options] - Optional transformation options that may be used for creating the annotation entity.
    * @returns {Nullable<[RTENodeAnnotationMapKey, RTENodeAnnotationMapValue]>} Returning a nullable tuple containing a key and a
    * value from the `RTENodeAnnotationMapKey` and `RTENodeAnnotationMapValue` types.
    */
-  private static createAnnotationEntity;
+  protected static createAnnotationEntity(type: keyof VegaRTETextAnnotations, value: unknown, options?: VegaRTETransformOptions): Nullable<[RTENodeAnnotationMapKey, RTENodeAnnotationMapValue]>;
   /**
    * @inheritDoc
    */
   toJSON(): VegaRTETextNode;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
   /**
    * Creates a new RTETextNode with the specified text and copies the parent block and annotation map from the original node.
    *
@@ -52,6 +68,26 @@ export declare class RTETextNode extends RTENode<RTETextBlock> {
    * @returns {boolean}  It returns `true` if the node is empty
    */
   isEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  isTextNode(): this is RTETextNode;
+  /**
+   * @inheritDoc
+   */
+  getRangeEndOffset(): number;
+  /**
+   * @inheritDoc
+   */
+  getRangeContainer(): Nullable<Node>;
+  /**
+   * @inheritDoc
+   */
+  isContentEditable(): boolean;
+  /**
+   * Registers the action strategies for the RTETextNode.
+   */
+  protected registerModifyStrategy(): void;
   /**
    * @inheritDoc
    */
@@ -73,4 +109,23 @@ export declare class RTETextNode extends RTENode<RTETextBlock> {
    * @param {RTETextNode} selectedNode - The selected node
    */
   private syncUpSelectedNodes;
+  /**
+   * Render the text node with the inline HTML wrapper.
+   *
+   * @param {VegaInlineHtmlSchema} inlineHtmlNode - The inline HTML schema to wrap the text node.
+   * @returns {string} The HTML string representation of the text node wrapped with the inline HTML.
+   */
+  private renderWithWrapperStr;
+  /**
+   * Generates the HTML representation of the text node.
+   *
+   * @returns {string} The HTML string representation of the text node.
+   */
+  private renderTextStr;
+  /**
+   * Determines if the text node should be rendered as plain text.
+   *
+   * @returns {boolean} `true` if the text node should be rendered as plain text, otherwise `false`.
+   */
+  private shouldRenderAsPlainText;
 }

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

@@ -91,13 +91,6 @@ export declare class RTERange {
    * @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.
    *

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

@@ -0,0 +1,9 @@
+import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../interface';
+import { RTEBlock } from '../blocks/block.abstract';
+import { RTENode } from '../nodes/node.abstract';
+/**
+ * Base renderer class for the rich text editor.
+ */
+export declare abstract class VegaRTEBaseRenderer<T extends RTENode | RTEBlock, R extends VegaRTERenderResult | HTMLElement> {
+  abstract render(entity: T, renderContext?: RTERenderContext, createElement?: VegaRTECreateElementFunction): R;
+}

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

@@ -1,28 +1,15 @@
 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;
+import { RTERenderContext, VegaRTECreateElementFunction } from '../../../interface';
+import { VegaRTEBaseRenderer } from '../base-renderer';
+export declare abstract class RTEBlockRenderer extends VegaRTEBaseRenderer<RTEBlock, HTMLElement> {
+  abstract render(block: RTEBlock, renderContext: RTERenderContext, createElement?: VegaRTECreateElementFunction): 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
+   * The attributes of the element rendered by the block
    *
    * @param {RTEBlock} block - RTE block entity
-   * @returns {string} - Annotation style
+   * @returns {Record<string, string>} - element  props
    */
-  protected getClasses(block: RTEBlock): string;
+  protected getCustomAttrs(block: RTEBlock): Record<string, string>;
 }

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

@@ -1,3 +1,4 @@
+import { VNode } from '../../../../../stencil-public-runtime';
 import { RTERenderContext } from '../../../interface';
 import { RTETextBlock } from '../../blocks/text-block';
 import { RTEBlockRenderer } from './block-renderer.abstract';
@@ -5,10 +6,12 @@ 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;
+  /**
+   * Renders the text nodes of the block(RTETextBlock, RTEListItemBlock), applying link group annotation rendering if present.
+   *
+   * @param {RTETextBlock} block - The text block containing nodes to render.
+   * @param {RTERenderContext} renderContext - The context for rendering.
+   * @returns {(HTMLElement | VNode)[]} An array of rendered HTMLElements.
+   */
+  protected renderNodes(block: RTETextBlock, renderContext: RTERenderContext): (HTMLElement | VNode)[];
 }

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

@@ -1,18 +1,10 @@
 import { RTERenderContext } from '../../../interface';
 import { RTEBlockRenderer } from './block-renderer.abstract';
 import { RTECodeBlock } from '../../blocks/code-block';
-import { RTEBlock } from '../../blocks/block.abstract';
 /**
  * The code block renderer.
  */
 declare class RTECodeBlockRenderer extends RTEBlockRenderer {
-  /**
-   * Check the input block type.
-   *
-   * @param {RTEBlock} block - The input block.
-   * @returns {boolean} - Return true if the input block is a code block.
-   */
-  canHandle(block: RTEBlock): boolean;
   /**
    * Render the code block.
    *

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

@@ -0,0 +1,8 @@
+import type { RTEHtmlBlock } from '../../blocks/html-block';
+import { RTERenderContext } from '../../../interface';
+import { RTEBlockRenderer } from './block-renderer.abstract';
+declare class RTEHTMLBlockRenderer extends RTEBlockRenderer {
+  render(block: RTEHtmlBlock, renderContext: RTERenderContext): HTMLElement;
+}
+declare const _default: RTEHTMLBlockRenderer;
+export default _default;

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

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