@globalpayments/vega 2.58.0 → 2.59.1

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;

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;
+}