@heartlandone/vega 2.80.0 → 2.82.0

package/dist/types/components/vega-rich-text-editor/dto/filter-styles-strategies/text-node/link-filter-styles-strategy.d.ts

@@ -1,12 +1,13 @@
-import { VegaRTEAnnotations } from '../../../interface';
+import { AnnotationStyle, VegaRTEAnnotations } from '../../../interface';
+import type { RTEBlock } from '../../blocks/block.abstract';
+import type { RTENode } from '../../nodes/node.abstract';
 import { RTEFilterStyles, RTEFilterStylesStrategy } from '../filter-styles-strategy.abstract';
 /**
- * Filters the default internal link styles (color) from `link.customStyle` when
- * parsing an RTETextNode. Vega applies these styles during standalone rendering;
- * they are redundant when parsed back and must not be persisted as custom overrides.
+ * The LinkFilterStylesStrategy is responsible for filtering link styles from text nodes that are annotated as links.
  */
 export declare class LinkFilterStylesStrategy extends RTEFilterStylesStrategy {
   protected stylesToBeFiltered: RTEFilterStyles;
+  protected elementTagName: string;
   /**
    * Filter default link styles from `link.customStyle` in annotations.
    *
@@ -14,4 +15,23 @@ export declare class LinkFilterStylesStrategy extends RTEFilterStylesStrategy {
    * @returns {VegaRTEAnnotations} The same annotations reference with link.customStyle cleaned up.
    */
   filterAnnotations(annotations: VegaRTEAnnotations): VegaRTEAnnotations;
+  /**
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * @inheritDoc
+   */
+  canRefill(blockOrNodeClassName: string, element: HTMLElement): boolean;
+  /**
+   * @inheritDoc
+   */
+  toCssText(): string;
+  /**
+   * Filters the inline styles for a link group annotation and updates the attributes accordingly.
+   *
+   * @param {Record<string, string | AnnotationStyle>} attributes The attributes of the link group annotation.
+   * @returns {Record<string, string | AnnotationStyle>} The updated attributes after filtering.
+   */
+  filterLinkGroupInlineStyles(attributes: Record<string, string | AnnotationStyle>): Record<string, string | AnnotationStyle>;
 }

package/dist/types/components/vega-rich-text-editor/dto/filter-styles-strategies/text-node/title-heading-node-filter-styles-strategy.d.ts

@@ -0,0 +1,62 @@
+import { VegaRTEAnnotations } from '../../../interface';
+import type { RTEBlock } from '../../blocks/block.abstract';
+import type { RTENode } from '../../nodes/node.abstract';
+import { RTEFilterStyles, RTEFilterStylesStrategy } from '../filter-styles-strategy.abstract';
+/**
+ * The TitleHeadingNodeFilterStylesStrategy is responsible for filtering styles from text nodes that are children of title and heading blocks.
+ * In title and heading blocks, the text nodes will have a default bold style.
+ */
+export declare class TitleHeadingNodeFilterStylesStrategy extends RTEFilterStylesStrategy {
+  static BOLD_STYLES: RTEFilterStyles;
+  static NON_HEADING_TITLE_ELEMENT_TAGS: string[];
+  protected stylesToBeFiltered: RTEFilterStyles;
+  protected elementTagName: string;
+  private parentBlockTypes;
+  private parentElementSelectors;
+  private toBeCheckedSelector;
+  /**
+   * Don't run filterAnnotations method, because already handle it in text format filter strategy.
+   *
+   * @inheritDoc
+   */
+  filterAnnotations(annotations: VegaRTEAnnotations): VegaRTEAnnotations;
+  /**
+   * Determines whether the dto instance is text node and its parent block is a heading or title.
+   *
+   * @param {RTEBlock | RTENode} blockOrNodeInstance - The block or node instance to check.
+   * @returns {boolean} - True if the instance is a text node and its parent block is a heading or title, false otherwise.
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * Check if the node is a text node and its parent block is a heading or title.
+   *
+   * @param {string} blockOrNodeClassName - The class name of the block or node instance to check.
+   * @param {HTMLElement} element - The HTML element of the node instance.
+   * @returns {boolean} True if the node is a text node and its parent block is a heading or title, false otherwise.
+   */
+  canRefill(blockOrNodeClassName: string, element: HTMLElement): boolean;
+  /**
+   * @inheritDoc
+   */
+  toCssText(): string;
+  /**
+   * Checks if the parent block of the given node instance is a heading or title.
+   *
+   * @param {RTENode | RTEBlock} blockOrNodeInstance - The node instance to check.
+   * @returns {boolean} True if the parent block is a heading or title, false otherwise.
+   */
+  private parentBlockIsHeadingOrTitle;
+  /**
+   * Check if the element is a descendant of a heading or title element.
+   * Traverses upward through the DOM, stopping at the block element or body element
+   * to avoid unbounded traversal to the document root.
+   *
+   * <h1><span>bold text</span></h1>
+   * <h1><a><span>link text</span></a></h1>
+   * <h1><a><b><span>nested text</span></b></a></h1>
+   *
+   * @param {HTMLElement} element - The element to check.
+   * @returns {boolean} True if the element is a descendant of a heading or title, false otherwise.
+   */
+  private isHeadingOrTitleChild;
+}

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

@@ -1,4 +1,4 @@
-import { VegaRTEBaseNode, VegaRTECodeBlock } from '../../interface';
+import { VegaRTEBaseNode, VegaRTECodeBlock, VegaRTETransformOptions } from '../../interface';
 import { AnnotationAction } from '../actions/annotation-action.abstract';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 import { RTECodeBlock } from '../blocks/code-block';
@@ -6,10 +6,14 @@ import { NodeTypeEnum } from './node.abstract';
 import { InternalAnnotationTypeEnum } from '../annotations/annotation.abstract';
 import { SelectionRangeAnnotation } from '../annotations/selection-range-annotation';
 import { RTEDecoratorNode } from './decorator-node';
+import { CustomStyleAnnotation } from '../annotations/custom-style-annotation';
+import { CommonAnnotationTypeEnum } from '../annotations/common-annotation.abstract';
 declare type VegaRTECodeNode = VegaRTEBaseNode & {
   text: string;
   language?: VegaRTECodeBlock['language'];
 };
+declare type CodeBlockNodeAnnotationKey = InternalAnnotationTypeEnum.SELECTION_RANGE | CommonAnnotationTypeEnum.CUSTOM_STYLE;
+declare type CodeBlockNodeAnnotationValue = SelectionRangeAnnotation | CustomStyleAnnotation;
 /**
  * RTE code node DTO class.
  */
@@ -18,7 +22,7 @@ export declare class RTECodeBlockNode extends RTEDecoratorNode<RTECodeBlock> {
   parent: RTECodeBlock;
   text: string;
   language?: VegaRTECodeBlock['language'];
-  annotationMap: Map<InternalAnnotationTypeEnum.SELECTION_RANGE, SelectionRangeAnnotation>;
+  annotationMap: Map<CodeBlockNodeAnnotationKey, CodeBlockNodeAnnotationValue>;
   constructor(id: string, content: string, language: VegaRTECodeBlock['language'], parentBlock: RTECodeBlock);
   /**
    * The code node toJSON method will called internal.
@@ -29,7 +33,7 @@ export declare class RTECodeBlockNode extends RTEDecoratorNode<RTECodeBlock> {
   /**
    * @inheritDoc
    */
-  toHtml(): string;
+  toHtml(options?: VegaRTETransformOptions): string;
   /**
    * @inheritDoc
    */

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

@@ -32,7 +32,7 @@ export declare class RTEImageNode extends RTEDecoratorNode<RTEImageBlock> {
   /**
    * @inheritDoc
    */
-  toHtml(): string;
+  toHtml(options?: VegaRTETransformOptions): string;
   /**
    * @inheritDoc
    */

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

@@ -1,4 +1,4 @@
-import { AnnotationStyle, RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, RTERenderContext, VegaRTEImageAnnotations, VegaRTETextAnnotations, VegaRTETransformOptions } from '../../interface';
+import { AnnotationStyle, RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, RTERenderContext, VegaRTETransformOptions, VegaRTEImageAnnotations, VegaRTETextAnnotations } from '../../interface';
 import { AnnotationAction } from '../actions/annotation-action.abstract';
 import { RTEBlock } from '../blocks/block.abstract';
 import { Nullable } from '../../../../types/general';
@@ -94,10 +94,11 @@ export declare abstract class RTENode<P extends RTEBlock = RTEBlock> {
   /**
    * Generate attributes as string
    *
+   * @param {VegaRTETransformOptions} [options] - Options for converting the node to HTML.
    * @param {...string} attrs - Additional attributes to include
    * @returns {string} - Attributes as string
    */
-  protected generateAttributeString(...attrs: string[]): string;
+  protected generateAttributeString(options?: VegaRTETransformOptions, ...attrs: string[]): string;
   /**
    * apply annotation action or modify content action
    *
@@ -136,9 +137,10 @@ export declare abstract class RTENode<P extends RTEBlock = RTEBlock> {
   /**
    * Convert the node to HTML.
    *
+   * @param {VegaRTETransformOptions} [options] - Options for converting the node to HTML.
    * @returns {string} The HTML string representing the node.
    */
-  abstract toHtml(): string;
+  abstract toHtml(options?: VegaRTETransformOptions): string;
   /**
    * Convert the node to a JSON object.
    *

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

@@ -4,9 +4,16 @@ 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';
+import { InlineHtmlAnnotation } from '../annotations/inline-html-annotation';
 export declare type Link = {
   href?: string;
 };
+export declare type InlineHtmlTagDescriptor = {
+  htmlTag: string;
+  attrStr: string;
+  groupId?: string;
+  annotation: InlineHtmlAnnotation;
+};
 /**
  * Text node
  */
@@ -60,7 +67,7 @@ export declare class RTETextNode extends RTENode<RTETextBlock> {
   /**
    * @inheritDoc
    */
-  toHtml(): string;
+  toHtml(options?: VegaRTETransformOptions): string;
   /**
    * Creates a new RTETextNode with the specified text and copies the parent block and annotation map from the original node.
    *
@@ -94,6 +101,31 @@ export declare class RTETextNode extends RTENode<RTETextBlock> {
    * @inheritDoc
    */
   isContentEditable(): boolean;
+  /**
+   * Returns the inline HTML wrapper descriptor at the given depth in the
+   * annotation chain. Depth 0 is the outermost wrapper, depth 1 is its child, etc.
+   *
+   * @param {number} depth - Zero-based depth in the inline HTML chain.
+   * @returns {InlineHtmlTagDescriptor | null} The wrapper descriptor at that depth, or `null`.
+   */
+  getInlineHtmlTagAtDepth(depth: number): InlineHtmlTagDescriptor | null;
+  /**
+   * Renders the node starting from the given depth in the inline HTML chain.
+   * Depth 0 renders the full chain (equivalent to {@link toHtml} for inline HTML nodes).
+   *
+   * @param {number} depth - Zero-based depth to start rendering from.
+   * @param {VegaRTETransformOptions} [options] - Optional conversion options that may affect how the text node is rendered as HTML.
+   * @returns {string} HTML string from that depth onward.
+   */
+  renderHtmlFromDepth(depth: number, options?: VegaRTETransformOptions): string;
+  /**
+   * Traverses the inline HTML annotation chain to the given depth and returns
+   * the annotation at that level, or `null` if the chain is shorter.
+   *
+   * @param {number} depth - Zero-based depth (0 = outermost annotation).
+   * @returns {Nullable<InlineHtmlAnnotation>} The annotation at that depth, or `null`.
+   */
+  getInlineHtmlAnnotationAtDepth(depth: number): Nullable<InlineHtmlAnnotation>;
   /**
    * Registers the action strategies for the RTETextNode.
    */
@@ -120,15 +152,22 @@ export declare class RTETextNode extends RTENode<RTETextBlock> {
    */
   private syncUpSelectedNodes;
   /**
-   * Render the text node with the inline HTML wrapper.
-   *
-   * @param {VegaInlineHtmlSchema} inlineHtmlNode - The inline HTML schema to wrap the text node.
+   * @param {InlineHtmlAnnotation} inlineHtmlNode - The inline HTML annotation to wrap the text node.
+   * @param {VegaRTETransformOptions} [options] - Optional conversion options that may affect how the text node is rendered as HTML.
    * @returns {string} The HTML string representation of the text node wrapped with the inline HTML.
    */
   private renderWithWrapperStr;
+  /**
+   * Generate the attribute string for the inline HTML annotation
+   *
+   * @param {InlineHtmlAnnotation} annotation - The inline HTML annotation
+   * @returns {string} The attribute string for the inline HTML annotation
+   */
+  private annotationAttrStr;
   /**
    * Generates the HTML representation of the text node.
    *
+   * @param {VegaRTETransformOptions} [options] - Optional conversion options that may affect how the text node is rendered as HTML.
    * @returns {string} The HTML string representation of the text node.
    */
   private renderTextStr;

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

@@ -1,6 +1,7 @@
 import { VNode } from '../../../../../stencil-public-runtime';
 import { RTERenderContext } from '../../../interface';
 import { RTETextBlock } from '../../blocks/text-block';
+import { RTETextNode } from '../../nodes/text-node';
 import { RTEBlockRenderer } from './block-renderer.abstract';
 /**
  * Abstract class for rendering blocks that contain text nodes with support for rendering text with link styles.
@@ -14,4 +15,28 @@ export declare abstract class RTEBlockTextNodesRenderer extends RTEBlockRenderer
    * @returns {(HTMLElement | VNode)[]} An array of rendered HTMLElements.
    */
   protected renderNodes(block: RTETextBlock, renderContext: RTERenderContext): (HTMLElement | VNode)[];
+  /**
+   * Recursively groups `nodes` by their inline HTML wrapper `groupId` at the given
+   * `depth`, emitting a single shared wrapper element for adjacent siblings and
+   * descending into the next depth for each group.  Nodes without a `groupId` at
+   * the current depth are rendered individually (same as the non-grouped path).
+   *
+   * @param {RTETextNode[]} nodes - The nodes to render.
+   * @param {number} depth - Current depth in the inline HTML chain (0 = outermost).
+   * @param {RTERenderContext} renderContext - The render context.
+   * @returns {(HTMLElement | VNode)[]} Rendered nodes/elements at this depth.
+   */
+  protected renderGroupedNodesAtDepth(nodes: RTETextNode[], depth: number, renderContext: RTERenderContext): (HTMLElement | VNode)[];
+  /**
+   * Renders a single node starting from the given inline HTML depth.
+   * At depth 0 the full annotation chain is rendered normally.
+   * At depth > 0 the chain begins at that depth (the outer wrappers have
+   * already been emitted by the grouping logic above).
+   *
+   * @param {RTETextNode} node - The node to render.
+   * @param {number} depth - Depth in the inline HTML chain to start from.
+   * @param {RTERenderContext} renderContext - The render context.
+   * @returns {HTMLElement | VNode} The rendered node.
+   */
+  private renderNodeFromDepth;
 }

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

@@ -3,6 +3,11 @@ import { RTETextBlock } from '../../blocks/text-block';
 import { RTEBlockTextNodesRenderer } from './block-text-nodes-renderer.abstract';
 declare class RTETextBlockRenderer extends RTEBlockTextNodesRenderer {
   render(block: RTETextBlock, renderContext: RTERenderContext): HTMLElement;
+  /**
+   * Returns the promotable inline HTML tag when the block wraps exactly one
+   * inline-HTML element (e.g. `<summary>`, `<section>`), or `null` otherwise.
+   */
+  private getOuterInlineTag;
 }
 declare const _default: RTETextBlockRenderer;
 export default _default;

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

@@ -1,6 +1,18 @@
 import { RTENodeRenderer } from './node-renderer.abstract';
 import { RTETextNode } from '../../nodes/text-node';
+import { Nullable } from '../../../../../types/general';
+import { InlineHtmlAnnotation } from '../../annotations/inline-html-annotation';
 declare class RTETextNodeRenderer extends RTENodeRenderer {
+  /**
+   * Renders the text node wrapped in the given annotation chain starting from the
+   * provided annotation level. Used by the grouped node renderer to render a node
+   * inside an already-emitted outer wrapper.
+   *
+   * @param {RTETextNode} node - The text node to render.
+   * @param {Nullable<InlineHtmlAnnotation>} annotation - Starting annotation, or null for text-only.
+   * @returns {HTMLElement} The rendered element.
+   */
+  renderFromAnnotation(node: RTETextNode, annotation: Nullable<InlineHtmlAnnotation>): HTMLElement;
   render(node: RTETextNode): HTMLElement;
   private renderWithWrapper;
   private renderText;

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

@@ -12,6 +12,7 @@ import type { VegaRTEContent } from '../dto/content-state';
 import { ActionHandlerInterceptor } from '../dto/action-handle-strategies/action-handle-interceptor.abstract';
 import { AnnotationGeneratorStrategyAbstract } from '../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/annotation-generator-strategy.abstract';
 import { AnnotationAction } from '../dto/actions/annotation-action.abstract';
+import { RTEFilterStylesStrategy } from '../dto/filter-styles-strategies/filter-styles-strategy.abstract';
 /**
  * Abstract class for Vega Rich Text Editor extensions.
  */
@@ -37,6 +38,13 @@ export declare abstract class VegaRTEExtension {
    * @param {ActionHandlerInterceptor<ModifyContentAction, RTENode | RTEBlock | VegaRTEContent>} strategy - The interceptor to register.
    */
   static registerActionHandlerInterceptor(nodeOrBlockClassName: string, actionType: string, strategy: ActionHandlerInterceptor<ModifyContentAction, RTENode | RTEBlock | VegaRTEContent>): void;
+  /**
+   * Registers a filter styles strategy for a specific block or node class.
+   *
+   * @param {string} blockOrNodeClassName - The name of the block or node class.
+   * @param {RTEFilterStylesStrategy} strategy - The filter styles strategy to register.
+   */
+  static registerFilterStylesStrategy(blockOrNodeClassName: string, strategy: RTEFilterStylesStrategy): void;
   /**
    * Initializes the RTE extension with the provided context.
    *

package/dist/types/components/vega-rich-text-editor/extensions/table/annotations/table-annotation.d.ts

@@ -1,5 +1,6 @@
 import { Nullable } from '../../../../../types/general';
 import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
+import { AnnotationStyle } from '../../../interface';
 import { RTETableColorAnnotation } from './table-color-annotation';
 export declare type VegaRTETableAnnotation = {
   backgroundColor?: Nullable<string>;
@@ -27,6 +28,7 @@ export declare type VegaRTETableAlignment = 'left' | 'center' | 'right';
 export declare class RTETableAnnotation extends BlockAnnotation<RTETableExtensionAnnotationTypeEnum.TABLE> {
   static readonly DEFAULT_BORDER_COLLAPSE: string;
   static readonly DEFAULT_ALIGNMENT: VegaRTETableAlignment;
+  static readonly DEFAULT_ALIGNMENT_STYLE_VALUE: string;
   readonly type: RTETableExtensionAnnotationTypeEnum.TABLE;
   backgroundColor?: Nullable<string>;
   border?: Nullable<VegaRTETableBorderType>;
@@ -42,6 +44,12 @@ export declare class RTETableAnnotation extends BlockAnnotation<RTETableExtensio
    * @inheritDoc
    */
   static from(value: VegaRTETableAnnotation, useInternalStyle?: boolean): [RTETableExtensionAnnotationTypeEnum.TABLE, RTETableAnnotation];
+  /**
+   * Get the default styles for the table annotation.
+   *
+   * @returns {AnnotationStyle} The default styles for the table annotation.
+   */
+  static getDefaultStyles(): AnnotationStyle;
   /**
    * Generates the CSS border string from the border properties.
    *

package/dist/types/components/vega-rich-text-editor/extensions/table/annotations/table-caption-annotation.d.ts

@@ -7,6 +7,12 @@ import { Nullable } from '../../../../../types/general';
  */
 export declare class RTETableCaptionAnnotation extends BlockAnnotation<RTETableExtensionAnnotationTypeEnum.CAPTION> {
   readonly type: RTETableExtensionAnnotationTypeEnum.CAPTION;
+  /**
+   * Get the default styles for the table caption annotation.
+   *
+   * @returns {AnnotationStyle} The default styles for the table caption annotation.
+   */
+  static getDefaultStyles(): AnnotationStyle;
   /**
    * @inheritDoc
    */
@@ -22,7 +28,7 @@ export declare class RTETableCaptionAnnotation extends BlockAnnotation<RTETableE
   /**
    * @inheritDoc
    */
-  toJSON(): Nullable<Record<'caption', unknown>>;
+  toJSON(): Nullable<Record<'caption', boolean>>;
   /**
    * Get the background color for the caption based on the current theme mode.
    *

package/dist/types/components/vega-rich-text-editor/extensions/table/annotations/table-cell-annotation.d.ts

@@ -1,7 +1,7 @@
 import { Nullable } from '../../../../../types/general';
 import { RTETableExtensionAnnotationTypeEnum, VegaRTETableBorderType } from './table-annotation';
 import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
-import { RTERenderContext } from '../../../interface';
+import { AnnotationStyle, RTERenderContext } from '../../../interface';
 import { RTETableColorAnnotation } from './table-color-annotation';
 export declare type VegaRTETableCellAnnotation = {
   backgroundColor?: Nullable<string>;
@@ -22,6 +22,7 @@ export declare type VegaRTETableVerticalAlignType = 'top' | 'middle' | 'bottom';
 export declare class RTETableCellAnnotation extends BlockAnnotation<RTETableExtensionAnnotationTypeEnum.CELL> {
   static readonly DEFAULT_PADDING: string;
   static readonly DEFAULT_BORDER: VegaRTETableBorderType;
+  static readonly DEFAULT_BORDER_RGB_COLOR: string;
   static readonly DEFAULT_HORIZONTAL_TEXT_ALIGN: VegaRTETableTextAlignType;
   static readonly DEFAULT_VERTICAL_TEXT_ALIGN: VegaRTETableVerticalAlignType;
   static readonly DEFAULT_CELL_MIN_WIDTH: string;
@@ -44,6 +45,13 @@ export declare class RTETableCellAnnotation extends BlockAnnotation<RTETableExte
    * @inheritDoc
    */
   static from(cellAnnotation: VegaRTETableCellAnnotation, useInternalStyle?: boolean): [RTETableExtensionAnnotationTypeEnum.CELL, RTETableCellAnnotation];
+  /**
+   * Get the default styles for the table annotation.
+   *
+   * @param {boolean} isHexColor - Whether to return color values as hex codes.
+   * @returns {AnnotationStyle} The default styles for the table annotation.
+   */
+  static getDefaultStyles(isHexColor?: boolean): AnnotationStyle;
   /**
    * Generates the CSS border string from the border properties.
    *

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

@@ -53,7 +53,7 @@ export declare class RTETableBlock extends RTEBlock<VegaRTEContent | RTEHtmlBloc
   /**
    * @inheritDoc
    */
-  toHtml(): string;
+  toHtml(options?: VegaRTETransformOptions): string;
   /**
    * @inheritDoc
    */

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-body-block.d.ts

@@ -34,7 +34,7 @@ export declare class RTETableBodyBlock extends RTEBlock<RTETableBlock, RTETableR
   /**
    * @inheritDoc
    */
-  toHtml(): string;
+  toHtml(options?: VegaRTETransformOptions): string;
   /**
    * @inheritDoc
    */

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-caption-block.d.ts

@@ -1,10 +1,13 @@
 import { RTEBlock } from '../../../dto/blocks/block.abstract';
-import { VegaRTEBlockBase, VegaRTETextBlock, VegaRTETransformOptions } from '../../../interface';
+import { VegaRTEBlockAnnotations, VegaRTEBlockBase, VegaRTETextBlock, VegaRTETransformOptions } from '../../../interface';
 import { RTETableBlock } from './table-block';
 import { RTENode } from '../../../dto/nodes/node.abstract';
 export declare type VegaRTETableCaptionBlock = VegaRTEBlockBase & {
   type: string;
   children: VegaRTETextBlock[];
+  annotations?: VegaRTEBlockAnnotations & {
+    caption?: boolean;
+  };
 };
 /**
  * Represents the optional caption block for a table.
@@ -33,7 +36,7 @@ export declare class RTETableCaptionBlock extends RTEBlock<RTETableBlock, RTEBlo
   /**
    * @inheritDoc
    */
-  toHtml(): string;
+  toHtml(options?: VegaRTETransformOptions): string;
   /**
    * @inheritDoc
    */

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-cell-block.d.ts

@@ -49,7 +49,7 @@ export declare class RTETableCellBlock extends RTEBlock<RTETableRowBlock, RTEBlo
   /**
    * @inheritDoc
    */
-  toHtml(): string;
+  toHtml(options?: VegaRTETransformOptions): string;
   /**
    * @inheritDoc
    */

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-head-block.d.ts

@@ -34,7 +34,7 @@ export declare class RTETableHeadBlock extends RTEBlock<RTETableBlock, RTETableR
   /**
    * @inheritDoc
    */
-  toHtml(): string;
+  toHtml(options?: VegaRTETransformOptions): string;
   /**
    * @inheritDoc
    */

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-head-cell-block.d.ts

@@ -26,7 +26,7 @@ export declare class RTETableHeadCellBlock extends RTETableCellBlock {
   /**
    * @inheritDoc
    */
-  toHtml(): string;
+  toHtml(options?: VegaRTETransformOptions): string;
   /**
    * @inheritDoc
    */

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-row-block.d.ts

@@ -36,7 +36,7 @@ export declare class RTETableRowBlock extends RTEBlock<RTETableBodyBlock | RTETa
   /**
    * @inheritDoc
    */
-  toHtml(): string;
+  toHtml(options?: VegaRTETransformOptions): string;
   /**
    * @inheritDoc
    */

package/dist/types/components/vega-rich-text-editor/extensions/table/filter-styles-strategies/table-block/table-block-filter-styles-strategy.d.ts

@@ -0,0 +1,29 @@
+import { RTEBlock } from '../../../../dto/blocks/block.abstract';
+import { RTEFilterStyles, RTEFilterStylesStrategy } from '../../../../dto/filter-styles-strategies/filter-styles-strategy.abstract';
+import { RTENode } from '../../../../dto/nodes/node.abstract';
+/**
+ * A strategy defines how to filter and refill styles for table elements.
+ */
+export declare class TableBlockFilterStylesStrategy extends RTEFilterStylesStrategy {
+  protected stylesToBeFiltered: RTEFilterStyles;
+  protected elementTagName: string;
+  /**
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * @inheritDoc
+   */
+  canRefill(blockOrNodeClassName: string, element: HTMLElement): boolean;
+  /**
+   * @inheritDoc
+   */
+  toCssText(): string;
+  /**
+   * Checks if the given class name corresponds to a table block.
+   *
+   * @param {string} className - The class name to check.
+   * @returns {boolean} - True if it's a table block, false otherwise.
+   */
+  private isTableBlock;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/filter-styles-strategies/table-caption/table-caption-filter-styles-strategy.d.ts

@@ -0,0 +1,29 @@
+import { RTEBlock } from '../../../../dto/blocks/block.abstract';
+import { RTEFilterStyles, RTEFilterStylesStrategy } from '../../../../dto/filter-styles-strategies/filter-styles-strategy.abstract';
+import { RTENode } from '../../../../dto/nodes/node.abstract';
+/**
+ * A strategy defines how to filter and refill styles for table caption elements.
+ */
+export declare class TableCaptionFilterStylesStrategy extends RTEFilterStylesStrategy {
+  protected stylesToBeFiltered: RTEFilterStyles;
+  protected elementTagName: string;
+  /**
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * @inheritDoc
+   */
+  canRefill(blockOrNodeClassName: string, element: HTMLElement): boolean;
+  /**
+   * @inheritDoc
+   */
+  toCssText(): string;
+  /**
+   * Checks if the given class name corresponds to a table caption block.
+   *
+   * @param {string} className - The class name to check.
+   * @returns {boolean} - True if it's a table caption block, false otherwise.
+   */
+  private isTableCaption;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/filter-styles-strategies/table-cell/table-cell-filter-styles-strategy.d.ts

@@ -0,0 +1,46 @@
+import { Nullable } from '../../../../../../types/general';
+import { RTEBlock } from '../../../../dto/blocks/block.abstract';
+import { RTEFilterStyles, RTEFilterStylesStrategy } from '../../../../dto/filter-styles-strategies/filter-styles-strategy.abstract';
+import { RTENode } from '../../../../dto/nodes/node.abstract';
+import { RTEFilterInlineStylesResult } from '../../../../interface';
+/**
+ * A strategy defines how to filter and refill styles for table cell elements.
+ */
+export declare class TableCellFilterStylesStrategy extends RTEFilterStylesStrategy {
+  protected stylesToBeFiltered: RTEFilterStyles;
+  protected elementTagName: string;
+  private stylesWithRGBColor;
+  private cellBlockClassName;
+  constructor(cellType?: 'td' | 'th');
+  /**
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * The table cell border color can be represented in different formats (e.g., hex, rgb), so we need to ensure that we can handle both cases.
+   *
+   * @inheritDoc
+   */
+  filterAndDeleteStyles(fullStyles: Nullable<RTEFilterStyles>, classNames: Nullable<string[]>): RTEFilterInlineStylesResult;
+  /**
+   * @inheritDoc
+   */
+  canRefill(blockOrNodeClassName: string, element: HTMLElement): boolean;
+  /**
+   * @inheritDoc
+   */
+  toCssText(): string;
+  /**
+   * Checks if the given class name corresponds to a table cell block.
+   *
+   * @param {string} className - The class name to check.
+   * @returns {boolean} - True if it's a table cell block, false otherwise.
+   */
+  private isTableCell;
+  /**
+   * Converts the default border color from RGB to HEX if necessary.
+   *
+   * @param {Nullable<RTEFilterStyles>} styles - The styles object to be modified.
+   */
+  private convertDefaultBorderColorFromRGBToHex;
+}

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

@@ -0,0 +1,8 @@
+import { AnnotationStyle } from '../interface';
+/**
+ * Creates a style map from the inline styles of an HTML element. This function extracts the 'style' attribute from the given element.
+ *
+ * @param {HTMLElement} element The HTML element from which to extract inline styles.
+ * @returns {AnnotationStyle} An object representing the custom style annotations.
+ */
+export declare function createStyleMapFromElement(element: HTMLElement): AnnotationStyle;