@heartlandone/vega 2.49.1 → 2.50.0-RTE-preview

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

@@ -0,0 +1,56 @@
+import { RTEBlockType, VegaRTECodeBlock } from '../../interface';
+import { VegaRTEContent } from '../content-state';
+import { RTENode } from '../nodes/node.abstract';
+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';
+/**
+ * The code block DTO class.
+ */
+export declare class RTECodeBlock extends RTEBlock {
+  static CODE_BLOCK_PLACEHOLDER_CLASS_NAME: string;
+  type: RTEBlockType;
+  parent: VegaRTEContent;
+  nodes: RTECodeBlockNode[];
+  constructor(id: string, content: string, language: VegaRTECodeBlock['language']);
+  /**
+   * Converts a VegaRTECodeBlock into an RTECodeBlock.
+   *
+   * @param {VegaRTECodeBlock} block - The block object
+   * @returns {RTECodeBlock} A RTECodeBlock class
+   */
+  static from(block: VegaRTECodeBlock): RTECodeBlock;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTECodeBlock;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  clone(): RTECodeBlock;
+  /**
+   * Apply action to block
+   *
+   * @param {ModifyContentAction} action - modify content action.
+   */
+  apply(action: AnnotationAction | ModifyContentAction): void;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * The code block is selected or not.
+   *
+   * @returns {boolean} - The boolean result.
+   */
+  isSelected(): boolean;
+}

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

@@ -21,6 +21,10 @@ export declare class RTEImageBlock extends RTEBlock {
    * @inheritDoc
    */
   toJSON(): VegaRTEImageBlock;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
   /**
    * @inheritDoc
    */

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

@@ -1,8 +1,9 @@
-import { RTEBlock } from './block.abstract';
-import { VegaRTEListBlock, VegaRTEListBlockType } from '../../interface';
+import { BlockAnnotationsEntity, RTEBlock } from './block.abstract';
+import { 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';
 /**
  * List block
  */
@@ -18,10 +19,27 @@ export declare class RTEListBlock extends RTEBlock {
    * @returns {RTEListBlock} Return an instance of `RTEListBlock`
    */
   static from(block: VegaRTEListBlock): 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
    */

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

@@ -21,6 +21,10 @@ export declare class RTEListItemBlock extends RTETextBlock {
    * @inheritDoc
    */
   toJSON(): VegaRTEListItemBlock;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
   /**
    * @inheritDoc
    */

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

@@ -1,11 +1,11 @@
 import { VegaRTETextBlock, VegaRTETextBlockType, VegaRTEBlockAnnotations, VegaRTETextStyleType } 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';
+export declare type RTETextBlockTagType = 'div' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'p';
 /**
  * Text block
  */
@@ -30,10 +30,10 @@ export declare class RTETextBlock extends RTEBlock {
    * @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,6 +51,10 @@ export declare class RTETextBlock extends RTEBlock {
    * @inheritDoc
    */
   toJSON(): VegaRTETextBlock;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
   /**
    * Clone the nodes to a new block
    *
@@ -76,6 +80,12 @@ export declare class RTETextBlock extends RTEBlock {
    * @returns {RTETextBlock} Paragraph.
    */
   createNewParagraph(): RTETextBlock;
+  /**
+   * Get the HTML tag for the block based on its type.
+   *
+   * @returns {RTETextBlockTagType} The HTML tag for the block.
+   */
+  getBlockTag(): RTETextBlockTagType;
   /**
    * @inheritDoc
    */

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

@@ -24,6 +24,13 @@ export declare class VegaRTEContent {
    * @returns {VegaRTEContent} An empty content state
    */
   static createEmptyContent(): VegaRTEContent;
+  /**
+   * Converts HTML content to a VegaRTEContent instance.
+   *
+   * @param {string} html - The HTML string to convert.
+   * @returns {VegaRTEContent} The converted content state.
+   */
+  static fromHtml(html: string): VegaRTEContent;
   /**
    * Clones the content state.
    *
@@ -37,6 +44,12 @@ export declare class VegaRTEContent {
    * @returns {VegaRTEContentBlock[]} The JSON array of blocks.
    */
   toJSON(): VegaRTEContentBlock[];
+  /**
+   * Converts the content state to HTML.
+   *
+   * @returns {string} The HTML representation of the content state.
+   */
+  toHtml(): 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

@@ -0,0 +1,45 @@
+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 { InternalAnnotationTypeEnum } from '../annotations/annotation.abstract';
+import { SelectionRangeAnnotation } from '../annotations/selection-range-annotation';
+declare type VegaRTECodeNode = VegaRTEBaseNode & {
+  text: string;
+  language?: VegaRTECodeBlock['language'];
+};
+/**
+ * RTE code node DTO class.
+ */
+export declare class RTECodeBlockNode extends RTENode {
+  type: NodeTypeEnum;
+  parentBlock: RTECodeBlock;
+  text: string;
+  language?: VegaRTECodeBlock['language'];
+  annotationMap: Map<InternalAnnotationTypeEnum.SELECTION_RANGE, SelectionRangeAnnotation>;
+  constructor(id: string, content: string, language: VegaRTECodeBlock['language'], parentBlock: RTECodeBlock);
+  /**
+   * The code node toJSON method will called internal.
+   *
+   * @returns {VegaRTECodeNode} - An object contains content property.
+   */
+  toJSON(): VegaRTECodeNode;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  clone(): RTECodeBlockNode;
+  /**
+   * @inheritDoc
+   */
+  protected doAnnotationActionApply(action: AnnotationAction): void;
+  /**
+   * @inheritDoc
+   */
+  protected doModifyActionApply(action: ModifyContentAction): void;
+}
+export {};

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

@@ -27,6 +27,10 @@ export declare class RTEImageNode extends RTENode {
    * @inheritDoc
    */
   clone(): RTEImageNode;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
   /**
    * @inheritDoc
    */

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

@@ -1,11 +1,13 @@
-import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTEBaseNode } from '../../interface';
+import { AnnotationStyle, RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, RTERenderContext, VegaRTEBaseNode, VegaRTEImageAnnotations, VegaRTETextAnnotations } 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';
 export declare enum NodeTypeEnum {
   TEXT = "TEXT",
-  IMAGE = "IMAGE"
+  IMAGE = "IMAGE",
+  CODE_BLOCK_NODE = "CODE_BLOCK_NODE"
 }
 export declare type NodeAnnotations = Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>;
 /**
@@ -17,6 +19,15 @@ export declare abstract class RTENode {
   abstract readonly type: NodeTypeEnum;
   abstract parentBlock: RTEBlock;
   protected constructor(id: string, annotationMap?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
+  /**
+   * 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
    *
@@ -38,6 +49,33 @@ export declare abstract class RTENode {
    * @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;
+  /**
+   * 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
    *
@@ -56,6 +94,12 @@ export declare abstract class RTENode {
   protected cloneAnnotations(): NodeAnnotations;
   abstract toJSON(): VegaRTEBaseNode;
   abstract clone(): RTENode;
+  /**
+   * Convert the node to HTML.
+   *
+   * @returns {string} The HTML string representing the node.
+   */
+  abstract toHtml(): string;
   protected abstract doAnnotationActionApply(action: AnnotationAction): void;
   protected abstract doModifyActionApply(action: ModifyContentAction): void;
 }

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, 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 = {
@@ -30,11 +31,15 @@ export declare class RTETextNode extends RTENode {
    * @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): 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.
    *

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

@@ -1,5 +1,5 @@
 import { RTEBlock } from '../../blocks/block.abstract';
-import { AnnotationStyle, RTERenderContext } from '../../../interface';
+import { RTERenderContext } from '../../../interface';
 import { Nullable } from '../../../../../types/general';
 export declare abstract class RTEBlockRenderer {
   /**
@@ -12,17 +12,10 @@ export declare abstract class RTEBlockRenderer {
   abstract render(block: RTEBlock, renderContext: RTERenderContext): HTMLElement;
   protected registerRef(ref: Nullable<HTMLElement>, block: RTEBlock): void;
   /**
-   * Get styles from annotations
+   * The attributes of the element rendered by the block
    *
    * @param {RTEBlock} block - RTE block entity
-   * @returns {AnnotationStyle} - Annotation style
+   * @returns {Record<string, string>} - element  props
    */
-  protected getStyles(block: RTEBlock): AnnotationStyle;
-  /**
-   * Get classes from annotations
-   *
-   * @param {RTEBlock} block - RTE block entity
-   * @returns {string} - Annotation style
-   */
-  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

@@ -5,10 +5,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 {
+  /**
+   * 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[]} An array of rendered HTMLElements.
+   */
   protected renderNodes(block: RTETextBlock, renderContext: RTERenderContext): HTMLElement[];
-  private renderLinkNodes;
-  private groupNodesByLink;
-  private isLinkGroup;
-  private renderLinkEditorWrapper;
-  private renderLink;
 }

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

@@ -0,0 +1,39 @@
+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.
+   *
+   * @param {RTECodeBlock} block - The code block.
+   * @param {RTERenderContext} renderContext - The render context.
+   * @returns {HTMLElement} - The code block container element and code node elements.
+   */
+  render(block: RTECodeBlock, renderContext: RTERenderContext): HTMLElement;
+  /**
+   * The current element used to define the upper and lower bounds of a code block and to ensure that they are reflected in the range object when the code block is selected.
+   *
+   * @param {'TOP' | 'BOTTOM'} position - The element position.
+   * @returns {HTMLElement} - The empty span element.
+   */
+  private renderPlaceholderElement;
+  /**
+   * Prevent the click event bubble, avoid the rich text content trigger focus event.
+   *
+   * @param {MouseEvent} e - The event object.
+   */
+  private preventParentDoFocus;
+}
+declare const _default: RTECodeBlockRenderer;
+export default _default;

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/text-block-renderer.d.ts

@@ -5,7 +5,6 @@ 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/code-block-node-renderer.d.ts

@@ -0,0 +1,37 @@
+import { RTENodeRenderer } from './node-renderer.abstract';
+import { RTERenderContext } from '../../../interface';
+import { RTECodeBlockNode } from '../../nodes/code-block-node';
+declare class RTECodeBlockNodeRenderer extends RTENodeRenderer {
+  render(node: RTECodeBlockNode, renderContext: RTERenderContext): HTMLElement;
+  /**
+   * Sync the code block DTO language and content when the component change event emit.
+   *
+   * @param {VegaCodeBlockValue} codeBlockValue - The code block value.
+   * @param {RTECodeBlockNode} node - The DTO class instance.
+   */
+  private handleCodeContentChange;
+  /**
+   * Remove the code block from RTE value when the component remove event emit.
+   *
+   * @param {ChangeManagerEventLike<unknown>} input - The internal event payload object.
+   * @param {RTECodeBlockNode} node - The DTO class instance.
+   */
+  private handleCodeBlockRemove;
+  /**
+   * The cursor should jump out of code block if enter three line breaks at the end.
+   *
+   * @param {string} oldCode - The old code content.
+   * @param {string} newCode - The new code content.
+   * @returns {boolean} - Boolean value.
+   */
+  private shouldSwitchOutOfCodeBlock;
+  /**
+   * Apply the selection action to code node or remove from the annotation map.
+   *
+   * @param {boolean} isSelected - The code block is focus or not.
+   * @param {RTECodeBlockNode} node - The DTO class instance.
+   */
+  private handleSelectionChange;
+}
+declare const _default: RTECodeBlockNodeRenderer;
+export default _default;

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

@@ -3,8 +3,30 @@ 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;
 }
 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,7 @@
-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 {
   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;
 }