@globalpayments/vega 2.58.0 → 2.59.0

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

@@ -1,13 +1,13 @@
 import { BlockAnnotation, BlockAnnotationTypeEnum } from './block-annotation.abstract';
-import { AnnotationStyle, VegaRTETextStyleType } from '../../interface';
+import { AnnotationStyle, RTERenderContext, 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);
+  textStyle: Nullable<VegaRTETextStyleType>;
+  constructor(textStyle: Nullable<VegaRTETextStyleType>);
   /**
    * Generate the map item for the annotations
    *
@@ -26,9 +26,11 @@ export declare class TextStyleAnnotation extends BlockAnnotation {
    */
   clone(): TextStyleAnnotation;
   /**
-   * Render the styles by block type
-   *
-   * @returns {AnnotationStyle} the styles to apply
+   * @inheritDoc
+   */
+  renderClass(options?: RTERenderContext): Nullable<string>;
+  /**
+   * @inheritDoc
    */
-  render(): AnnotationStyle;
+  renderStyle(options?: RTERenderContext): Nullable<AnnotationStyle>;
 }

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

@@ -1,6 +1,6 @@
 import { NodeAnnotation, NodeAnnotationTypeEnum } from './node-annotation.abstract';
 import { Nullable } from '../../../../types/general';
-import { AnnotationStyle } from '../../interface';
+import { AnnotationStyle, RTERenderContext } from '../../interface';
 /**
  * Annotation to make text with underline
  */
@@ -26,15 +26,11 @@ export declare class UnderlineAnnotation extends NodeAnnotation {
    */
   clone(): UnderlineAnnotation;
   /**
-   * Generate the class for the annotation
-   *
-   * @returns {Nullable<string>} - Annotation class
+   * @inheritDoc
    */
-  renderClass(): Nullable<string>;
+  renderClass(options?: RTERenderContext): Nullable<string>;
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} - Annotation style
+   * @inheritDoc
    */
-  render(): Nullable<AnnotationStyle>;
+  renderStyle(options?: RTERenderContext): Nullable<AnnotationStyle>;
 }

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

@@ -1,14 +1,17 @@
-import { RTEBlockType, VegaRTEBlockAnnotations, VegaRTEBlockBase } from '../../interface';
+import { AnnotationStyle, RTEBlockAnnotationMapKey, RTEBlockAnnotationMapValue, RTERenderContext, VegaRTEBlockAnnotations, VegaRTEBlockBase, VegaRTETransformOptions } 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 type { VegaRTEContent } from '../content-state';
 import { InternalAnnotationTypeEnum } from '../annotations/annotation.abstract';
 import { LinkGroupAnnotation } from '../annotations/link-group-annotation';
-import { RTENode } from '../nodes/node.abstract';
-import { RTEListItemBlock } from './list-item-block';
-export declare type BlockAnnotations = Map<keyof typeof BlockAnnotationTypeEnum | InternalAnnotationTypeEnum.LINK_GROUP, BlockAnnotation | LinkGroupAnnotation>;
+import type { RTENode } from '../nodes/node.abstract';
+import type { RTEListItemBlock } from './list-item-block';
+import { CustomAttributeAnnotation } from '../annotations/custom-attribute-annotation';
+import { ClassType } from '../../../../types/class.type';
+export declare type BlockAnnotations = Map<RTEBlockAnnotationMapKey, RTEBlockAnnotationMapValue>;
+export declare type BlockAnnotationsEntity = [RTEBlockAnnotationMapKey, RTEBlockAnnotationMapValue];
 declare type RTEBlockParentType = VegaRTEContent | RTEBlock;
 declare type RTEBlockChildrenType = RTEBlock | RTENode;
 /**
@@ -17,10 +20,17 @@ declare type RTEBlockChildrenType = RTEBlock | RTENode;
 export declare abstract class RTEBlock<P = RTEBlockParentType, C = RTEBlockChildrenType> {
   id: string;
   annotationMap: BlockAnnotations;
-  abstract type: RTEBlockType;
+  abstract type: string;
   abstract parent: P;
   abstract children: C[];
   protected constructor(id: string);
+  /**
+   * Creates a new instance of the block from the given JSON object.
+   *
+   * @param {unknown} json - The JSON object to create the block from.
+   * @param {VegaRTETransformOptions} options - Options for transforming the block.
+   */
+  static from(json: unknown, options?: VegaRTETransformOptions): InstanceType<ClassType<RTEBlock>>;
   /**
    * The function `createAnnotationEntity` creates a block annotation entity based on the provided type
    * and value.
@@ -30,10 +40,23 @@ export declare abstract class RTEBlock<P = RTEBlockParentType, C = RTEBlockChild
    * @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, value: unknown): Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>;
+  protected static createAnnotationEntity(type: keyof VegaRTEBlockAnnotations, value: unknown): Nullable<BlockAnnotationsEntity>;
+  /**
+   * Converts annotations to an array of block annotation entities.
+   *
+   * @param {BlockAnnotations} annotationMap - The map to store the converted annotations.
+   * @param {VegaRTEBlockAnnotations} annotations - The annotations to convert.
+   */
+  protected static convertAnnotationsToMap(annotationMap: BlockAnnotations, annotations: VegaRTEBlockAnnotations): void;
+  /**
+   * Check if the block should be rendered as a wrapper.
+   *
+   * @returns {boolean} - Returns true if the block is an internal wrapper.
+   */
+  shouldRenderAsInternalWrapper(): boolean;
   /**
    * Class to JSON object
    *
@@ -60,6 +83,33 @@ export declare abstract class RTEBlock<P = RTEBlockParentType, C = RTEBlockChild
    * @returns {boolean} True if the block is a list item block, false otherwise.
    */
   isListItemBlock(): this is RTEListItemBlock;
+  /**
+   * 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 standalone mode
+   * @returns {string} - Annotation style
+   */
+  getClasses(options?: RTERenderContext): string;
+  /**
+   * Get custom attribute annotation, excluding "class" and "style"
+   *
+   * @returns {Nullable<CustomAttributeAnnotation>} - custom attribute annotation
+   */
+  getCustomAttributesAnnotation(): Nullable<CustomAttributeAnnotation>;
+  /**
+   * Generate attributes as string
+   *
+   * @param {...string} attrs - Additional attributes to include
+   * @returns {string} - Attributes as string
+   */
+  protected generateAttributeString(...attrs: string[]): string;
   /**
    * Apply action to block
    *
@@ -91,6 +141,17 @@ export declare abstract class RTEBlock<P = RTEBlockParentType, C = RTEBlockChild
    */
   abstract isNotEmpty(): boolean;
   abstract getLastNode(): RTENode;
-  abstract clone(): RTEBlock;
+  /**
+   * Converts the block to HTML.
+   *
+   * @returns {string} The HTML string representing the block.
+   */
+  abstract toHtml(): string;
+  /**
+   * Clones the block.
+   *
+   * @returns {InstanceType<ClassType<RTEBlock>>} A new instance of the block with cloned properties.
+   */
+  abstract clone(): InstanceType<ClassType<RTEBlock>>;
 }
 export {};

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

@@ -5,13 +5,14 @@ import { RTEBlock } from './block.abstract';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 import { AnnotationAction } from '../actions/annotation-action.abstract';
 import { RTECodeBlockNode } from '../nodes/code-block-node';
+import { RTEHtmlBlock } from './html-block';
 /**
  * The code block DTO class.
  */
-export declare class RTECodeBlock extends RTEBlock<VegaRTEContent, RTECodeBlockNode> {
+export declare class RTECodeBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock, RTECodeBlockNode> {
   static CODE_BLOCK_PLACEHOLDER_CLASS_NAME: string;
   type: RTEBlockType;
-  parent: VegaRTEContent;
+  parent: VegaRTEContent | RTEHtmlBlock;
   children: RTECodeBlockNode[];
   constructor(id: string, content: string, language: VegaRTECodeBlock['language']);
   /**
@@ -25,6 +26,10 @@ export declare class RTECodeBlock extends RTEBlock<VegaRTEContent, RTECodeBlockN
    * @inheritDoc
    */
   toJSON(): VegaRTECodeBlock;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
   /**
    * @inheritDoc
    */

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

@@ -0,0 +1,42 @@
+import { RTEBlock } from './block.abstract';
+import { VegaRTEHtmlBlock, VegaRTETransformOptions, RTEContentBlock } from '../../interface';
+import { VegaRTEContent } from '../content-state';
+import { RTENode } from '../nodes/node.abstract';
+/**
+ * HTML Block
+ */
+export declare class RTEHtmlBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock, RTEContentBlock> {
+  type: 'html-block';
+  parent: VegaRTEContent | RTEHtmlBlock;
+  htmlTag: string;
+  children: RTEContentBlock[];
+  constructor(id: string, htmlTag: string);
+  /**
+   * Converts a VegaRTEHtmlBlock to an RTEHtmlBlock.
+   *
+   * @param {VegaRTEHtmlBlock} block - The VegaRTEHtmlBlock to convert.
+   * @param {VegaRTETransformOptions} [options] - Optional transformation options.
+   * @returns {RTEHtmlBlock} The converted RTEHtmlBlock.
+   */
+  static from(block: VegaRTEHtmlBlock, options?: VegaRTETransformOptions): RTEHtmlBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(): RTEHtmlBlock;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTEHtmlBlock;
+}

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

@@ -1,26 +1,32 @@
-import { RTEBlockType, VegaRTEImageBlock } from '../../interface';
+import { RTEBlockType, VegaRTETransformOptions, VegaRTEImageBlock } from '../../interface';
 import { RTEBlock } from './block.abstract';
 import { RTEImageNode } from '../nodes/image-node';
 import { VegaRTEContent } from '../content-state';
+import { RTEHtmlBlock } from './html-block';
 /**
  * Image block
  */
-export declare class RTEImageBlock extends RTEBlock<VegaRTEContent, RTEImageNode> {
+export declare class RTEImageBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock, RTEImageNode> {
   readonly type: RTEBlockType;
   children: RTEImageNode[];
-  parent: VegaRTEContent;
+  parent: VegaRTEContent | RTEHtmlBlock;
   constructor(id: string);
   /**
    * Converts a VegaRTEImageBlock object into an RTEImageBlock object by mapping nodes and creating annotations.
    *
    * @param {VegaRTEImageBlock} block - The block object to be converted.
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
    * @returns {RTEImageBlock} An instance of `RTEImageBlock`
    */
-  static from(block: VegaRTEImageBlock): RTEImageBlock;
+  static from(block: VegaRTEImageBlock, options?: VegaRTETransformOptions): RTEImageBlock;
   /**
    * @inheritDoc
    */
   toJSON(): VegaRTEImageBlock;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
   /**
    * @inheritDoc
    */

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

@@ -1,27 +1,48 @@
-import { RTEBlock } from './block.abstract';
-import { VegaRTEListBlock, VegaRTEListBlockType } from '../../interface';
+import { BlockAnnotationsEntity, RTEBlock } from './block.abstract';
+import { VegaRTETransformOptions, VegaRTEBlockAnnotations, VegaRTEListBlock, VegaRTEListBlockType } from '../../interface';
 import { RTEListItemBlock } from './list-item-block';
 import { VegaRTEContent } from '../content-state';
 import { RTETextNode } from '../nodes/text-node';
+import { Nullable } from '../../../../types/general';
+import { RTEHtmlBlock } from './html-block';
+export declare type RTEListBlockTagType = 'ol' | 'ul';
 /**
  * List block
  */
-export declare class RTEListBlock extends RTEBlock<VegaRTEContent | RTEListItemBlock, RTEListItemBlock> {
+export declare class RTEListBlock extends RTEBlock<VegaRTEContent | RTEListItemBlock | RTEHtmlBlock, RTEListItemBlock> {
   type: VegaRTEListBlockType;
   children: RTEListItemBlock[];
-  parent: RTEListItemBlock | VegaRTEContent;
-  constructor(id: string, type: VegaRTEListBlockType);
+  parent: RTEListItemBlock | VegaRTEContent | RTEHtmlBlock;
+  constructor(id: string, type: VegaRTEListBlockType, options?: VegaRTETransformOptions);
   /**
    * Converts a VegaRTEListBlock object to an RTEListBlock
    *
    * @param {VegaRTEListBlock} block - Converts a `VegaRTEListBlock` object into an `RTEListBlock`.
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
    * @returns {RTEListBlock} Return an instance of `RTEListBlock`
    */
-  static from(block: VegaRTEListBlock): RTEListBlock;
+  static from(block: VegaRTEListBlock, options?: VegaRTETransformOptions): RTEListBlock;
+  /**
+   * 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<BlockAnnotationsEntity>} The `createAnnotationEntity` function returns a nullable tuple containing a
+   * `BlockAnnotationTypeEnum` and a `BlockAnnotation` object.
+   */
+  protected static createAnnotationEntity(type: keyof VegaRTEBlockAnnotations, value: unknown): Nullable<BlockAnnotationsEntity>;
   /**
    * @inheritDoc
    */
   toJSON(): VegaRTEListBlock;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
   /**
    * @inheritDoc
    */
@@ -34,4 +55,10 @@ export declare class RTEListBlock extends RTEBlock<VegaRTEContent | RTEListItemB
    * @inheritDoc
    */
   clone(): RTEListBlock;
+  /**
+   * Returns the block tag based on the type of the list block.
+   *
+   * @returns {RTEListBlockTagType} - The block tag for the list block, either 'ol' or 'ul'.
+   */
+  getBlockTag(): RTEListBlockTagType;
 }

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

@@ -1,8 +1,7 @@
-import { VegaRTEListItemBlock } from '../../interface';
+import { VegaRTEListItemBlock, VegaRTETransformOptions } from '../../interface';
 import { RTETextNode } from '../nodes/text-node';
 import { RTEListBlock } from './list-block';
 import { RTETextBlock } from './text-block';
-import { RTEBlock } from './block.abstract';
 /**
  * List item block
  */
@@ -15,14 +14,15 @@ export declare class RTEListItemBlock extends RTETextBlock {
    */
   nestList?: RTEListBlock[];
   parent: RTEListBlock;
-  constructor(id: string, nestList?: RTEListBlock[]);
+  constructor(id: string, nestList?: RTEListBlock[], options?: VegaRTETransformOptions);
   /**
    * Converts a VegaRTEListItemBlock object to an RTEListItemBlock
    *
    * @param {VegaRTEListBlock} block - Converts a `VegaRTEListItemBlock` object into an `RTEListItemBlock`.
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
    * @returns {RTEListItemBlock} Return an instance of `RTEListItemBlock`
    */
-  static from(block: VegaRTEListItemBlock): RTEListItemBlock;
+  static from(block: VegaRTEListItemBlock, options?: VegaRTETransformOptions): RTEListItemBlock;
   /**
    * @inheritDoc
    */
@@ -30,7 +30,11 @@ export declare class RTEListItemBlock extends RTETextBlock {
   /**
    * @inheritDoc
    */
-  cloneWithNodes(nodes: RTETextNode[]): RTEBlock;
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  cloneWithNodes(nodes: RTETextNode[]): RTEListItemBlock;
   /**
    * @inheritDoc
    */

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
    */