@heartlandone/vega 2.79.0 → 2.81.0

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;

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

@@ -577,21 +577,25 @@ export type RTERenderCustomAttributes = {
  */
 export type VegaRTETransformOptions = {
 	/**
-	 * If `true`, automatically match the format of the content to the RTE's internal format.
+	 * If `true`, automatically match the format of the content to the RTE's internal format. Not used in the toHtml method.
 	 */
 	autoMatchFormat?: boolean;
 	/**
-	 * If `true`, skip custom style, class and attribute when generating annotations from HTML elements.
+	 * If `true`, skip custom style, class and attribute when generating annotations from HTML elements. Not used in the toHtml method.
 	 */
 	skipCustomAnnotations?: boolean;
+	/**
+	 * If `true`, filter inline styles when converting to HTML or refill inline styles when converting from HTML. Used in fromHtml and toHtml methods.
+	 */
+	filterInlineStyles?: boolean;
 };
 
 /**
  * Configuration for source edit mode.
  */
-export type VegaRTESourceEditConfig = Partial<Pick<VegaRTETransformOptions, 'autoMatchFormat'>> & {
-	// Other configurations can be added here as needed
-};
+export type VegaRTESourceEditConfig = Partial<
+	Pick<VegaRTETransformOptions, 'autoMatchFormat' | 'filterInlineStyles'>
+>;
 
 /**
  * Tokenized text node used for parsing.
@@ -713,6 +717,12 @@ export type VegaInlineHtmlSchema = {
 	 * Inline styles for the element.
 	 */
 	customStyle?: Record<string, string>;
+	/**
+	 * Grouping identifier — used at render time to merge adjacent text nodes
+	 * that share the same outer wrapper back into a single HTML element.
+	 * Assigned during fromHtml parsing.
+	 */
+	groupId?: string;
 };
 
 /**
@@ -889,3 +899,15 @@ export type RTETablePropertiesType = {
 	verticalAlign?: 'top' | 'middle' | 'bottom';
 	padding?: string;
 };
+
+export type RTEFilterInlineStylesResult = {
+	styles?: AnnotationStyle;
+	classNames?: string[];
+};
+
+export type VegaRTEGenerateStyleOptions = {
+	/**
+	 * If `true`, include font-face declarations for typography styles in the generated content style file.
+	 */
+	enableFontImports?: boolean;
+};

package/dist/types/components/vega-rich-text-editor/public-api.d.ts

@@ -35,3 +35,4 @@ export { ElementToDTOStrategy } from './slimmers/controllers/helper/element-to-d
 export { BlockToRTEBlockStrategyAbstract } from './slimmers/controllers/helper/element-to-dto-strategy/block-to-rte-block-strategy.abstract';
 export { htmlElementToAnnotationGenerator };
 export { VegaRTEPresetToolbarItems } from './constants/constant';
+export { RTEFilterStylesStrategy } from './dto/filter-styles-strategies/filter-styles-strategy.abstract';

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/custom-style-annotation-handler.d.ts

@@ -18,11 +18,4 @@ export declare class CustomStyleAnnotationHandler extends AnnotationGeneratorStr
    * @returns {VegaRTETextAnnotations} - Annotation.
    */
   handle(element: HTMLElement): VegaRTETextAnnotations;
-  /**
-   * Obtain and format the style of element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {AnnotationStyle} - Record<string, string>.
-   */
-  private generateCustomStyleAnnotations;
 }

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator.d.ts

@@ -6,7 +6,7 @@ import { ClassPrototype } from '../../../../../../../types/class.type';
 export declare type RTEDtoClassPrototype = ClassPrototype<RTEBlock | RTENode>;
 export declare type HtmlElementToAnnotationGenerateOptions = {
   parentAnnotations?: VegaRTETextAnnotations;
-} & Partial<Pick<VegaRTETransformOptions, 'autoMatchFormat' | 'skipCustomAnnotations'>>;
+} & Partial<Pick<VegaRTETransformOptions, 'autoMatchFormat' | 'skipCustomAnnotations' | 'filterInlineStyles'>>;
 /** Html element to annotations generator */
 declare class HtmlElementToAnnotationGenerator {
   private handlers;
@@ -30,6 +30,16 @@ declare class HtmlElementToAnnotationGenerator {
    * @returns {V} Generated annotations.
    */
   generate<T extends RTEDtoClassPrototype, V extends VegaRTEAnnotations>(targetDto: T, element: HTMLElement, options?: HtmlElementToAnnotationGenerateOptions): V;
+  /**
+   * Remove default text-style properties from customStyle.
+   * This prevents repeated styling when switching between source edit and normal mode.
+   *
+   * Note: This method mutates the customStyle object inside `annotations` in place and returns the same reference.
+   *
+   * @param {V} annotations - The generated annotations.
+   * @returns {V} The same annotations reference with customStyle cleaned up.
+   */
+  private removeTextStyleDefaultsFromCustomStyle;
 }
 declare const _default: HtmlElementToAnnotationGenerator;
 export default _default;

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/inline-html-annotation-handler.d.ts

@@ -5,7 +5,6 @@ import { VegaRTEAnnotations } from '../../../../../interface';
  * Handle inline html annotation
  */
 export declare class InlineHtmlAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
-  static canHandleTags: string[];
   private customAttributeHandler;
   private customStyleAnnotationHandler;
   private customClassAnnotationHandler;
@@ -25,4 +24,15 @@ export declare class InlineHtmlAnnotationHandler extends AnnotationGeneratorStra
    * @returns {Nullable<VegaInlineHtmlSchema>} - Inline html annotation.
    */
   private generateInlineHtmlAnnotation;
+  /**
+   * Immutably appends `toAppend` at the correct position in the chain — the
+   * deepest node whose `child.htmlTag` still matches `parentNode.nodeName`.
+   * Each level is reconstructed via spread so the original chain is never mutated.
+   *
+   * @param {VegaInlineHtmlSchema} node - Current chain node.
+   * @param {VegaInlineHtmlSchema} toAppend - Node to append at the tail.
+   * @param {ParentNode | null} parentNode - DOM parent of the element being processed.
+   * @returns {VegaInlineHtmlSchema} A new chain with `toAppend` inserted.
+   */
+  private appendToInlineHtmlChain;
 }