@heartlandone/vega 2.79.0 → 2.81.0

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

@@ -1,4 +1,8 @@
+import { VegaRTEAnnotations } from '../../interface';
 import { Nullable } from '../../../../types/general';
+import { RTEFilterInlineStylesResult } from '../../interface';
+import { RTEBlock } from '../blocks/block.abstract';
+import { RTENode } from '../nodes/node.abstract';
 export declare type RTEFilterStyles = Record<string, string>;
 /**
  * Abstract strategy class for filtering default styles in the rich text editor.
@@ -9,11 +13,80 @@ export declare type RTEFilterStyles = Record<string, string>;
  *   2. Annotation parsing strategies – strip redundant defaults when converting HTML → DTO.
  */
 export declare abstract class RTEFilterStylesStrategy {
+  /**
+   * Used for generate the style text, all styles should inside the content container.
+   * For example, if the style text is .v-rte-title {font-size: 24px;} the final generated style text should be .vega-rte-content .v-rte-title {font-size: 24px;} to make sure the styles are only applied to the elements inside the content container.
+   */
+  static RTE_CONTENT_CONTAINER_CLASS_NAME: string;
+  /**
+   * The class name to be added to the element if the styles are successfully filtered. This should be defined in the concrete implementation of the strategy if needed.
+   * After the class name is added to the element, it will be removed in the next refill process to avoid redundant class names.
+   * The class name will only be added when the styles are successfully extracted, which means the expected styles are present in the full styles object and have been deleted from it.
+   */
+  protected classNameToBeAdded: string;
   /**
    * The styles that the strategy is responsible for filtering.
    * Must be defined in each concrete implementation.
    */
   protected abstract stylesToBeFiltered: RTEFilterStyles;
+  /**
+   * Removes matched default styles from the `customStyle` property of the given annotations object.
+   * If all custom styles are defaults, the `customStyle` key is deleted entirely.
+   *
+   * @param {VegaRTEAnnotations} annotations - The annotations object (mutated in place).
+   * @returns {VegaRTEAnnotations} The same annotations reference.
+   */
+  filterAnnotations(annotations: VegaRTEAnnotations): VegaRTEAnnotations;
+  /**
+   * Filters and deletes the matched styles from the full styles object, add the corresponding class name if necessary, and returns the result.
+   *
+   * @param {RTEFilterStyles} fullStyles - The full set of styles to filter.
+   * @param {string[]} classNames - The class names to consider.
+   * @returns {RTEFilterInlineStylesResult} The filtered styles and class names.
+   */
+  filterAndDeleteStyles(fullStyles: Nullable<RTEFilterStyles>, classNames: Nullable<string[]>): RTEFilterInlineStylesResult;
+  /**
+   * Refills the external styles for a given HTML element based on a matched external style rule.
+   *
+   * @param {HTMLElement} element - The HTML element to apply the styles to. The element's existing styles will be merged with the matched rule's styles, and the matched class name will be removed from the element.
+   */
+  refillStyles(element: HTMLElement): void;
+  /**
+   * Determines if the strategy can filter the given block or node instance.
+   * Return false by default, concrete strategies should override this method to specify the filtering logic based on the block or node instance's properties, such as its type or annotations.
+   *
+   * @param {RTEBlock | RTENode} _blockOrNodeInstance - The block or node instance to check.
+   * @returns {boolean} True if the strategy can filter the instance, false otherwise.
+   */
+  canFilter(_blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * Determines if the strategy can refill styles for the given block or node class name and element.
+   * Return false by default to avoid unnecessary refill attempts, concrete strategies should override this method to specify the refilling logic based on the class name and element properties, such as the presence of certain attributes or existing styles.
+   *
+   * @param {string} _blockOrNodeClassName - The class name of the block or node.
+   * @param {HTMLElement} _element - The HTML element to apply the styles to.
+   * @returns {boolean} True if the strategy can refill styles, false otherwise.
+   */
+  canRefill(_blockOrNodeClassName: string, _element: HTMLElement): boolean;
+  /**
+   * Generates the CSS text to be applied to the element based on the strategy's styles to filter. This method should be implemented in the concrete strategy class to return the appropriate CSS text for the styles it handles.
+   * Return an empty string by default to avoid applying any styles when the method is not implemented in a concrete strategy.
+   *
+   * @returns {string} The CSS text to be applied to the element.
+   */
+  toCssText(): string;
+  /**
+   * Whether this strategy should always filter, regardless of `autoMatchFormat`.
+   * Override to `true` when the filtered styles are always emitted as inline
+   * styles by the DTO (e.g. image `vertical-align`), so stripping them from
+   * `customStyle` is always safe.
+   *
+   * Defaults to `false` – the strategy only runs when `autoMatchFormat` is enabled.
+   * Used before invoke the filterAnnotations method.
+   *
+   * @returns {boolean} Whether filtering should always apply.
+   */
+  get alwaysFilter(): boolean;
   /**
    * Removes configured default style properties from the target styles object.
    * Only properties whose value matches the configured default exactly are deleted.
@@ -22,4 +95,35 @@ export declare abstract class RTEFilterStylesStrategy {
    * @returns {boolean} `true` if at least one style was extracted.
    */
   protected extractAndDeleteMatchedStyles(styles: Nullable<RTEFilterStyles>): boolean;
+  /**
+   * Converts the styles map to a CSS text string.
+   *
+   * @param {string} tagName The HTML tag name.
+   * @param {string} [className] The optional class name.
+   * @returns {string} The CSS text string.
+   */
+  protected buildCssTextForStyles(tagName: string, className?: string): string;
+  /**
+   * Converts the styles map to a CSS text string.
+   *
+   * @param {RTEFilterStyles} [styles] The styles to convert. If not provided, the strategy's stylesToBeFiltered will be used.
+   * @returns {string} The CSS text string.
+   */
+  protected convertStylesMapToCssText(styles?: RTEFilterStyles): string;
+  /**
+   * Check if the styles of the block or node instance match the default paragraph styles.
+   *
+   * @param {RTEBlock | RTENode} blockOrNodeInstance - The block or node instance to check.
+   * @param {string[]} [checkedKeys] - Optional array of style keys to check. If not provided, all keys in stylesToBeFiltered will be checked.
+   * @returns {boolean} - True if the styles match the default paragraph styles, false otherwise.
+   */
+  protected isBlockOrNodeStylesMatchFilterStyles(blockOrNodeInstance: RTEBlock | RTENode, checkedKeys?: string[]): boolean;
+  /**
+   * Checks if the given itemStyles match the default paragraph styles.
+   *
+   * @param {RTEFilterStyles} itemStyles - The styles to check against the default paragraph styles.
+   * @param {string[]} [checkedKeys] - Optional array of style keys to check. If not provided, all keys in stylesToBeFiltered will be checked.
+   * @returns {boolean} - True if the itemStyles match the default paragraph styles, false otherwise.
+   */
+  protected isMatchFilterStyles(itemStyles: RTEFilterStyles, checkedKeys?: string[]): boolean;
 }

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

@@ -0,0 +1,28 @@
+import { RTEBlock } from '../../blocks/block.abstract';
+import { RTENode } from '../../nodes/node.abstract';
+import { RTEFilterStyles, RTEFilterStylesStrategy } from '../filter-styles-strategy.abstract';
+/**
+ * Filter styles strategy for image node, which defines the styles to be filtered and the conditions for filtering and refilling styles for image nodes.
+ */
+export declare class ImageFilterStylesStrategy extends RTEFilterStylesStrategy {
+  protected stylesToBeFiltered: RTEFilterStyles;
+  protected elementTagName: string;
+  /**
+   * Used for the filterAnnotations method.
+   *
+   * @returns {boolean} Always `true` — image defaults are emitted as inline styles.
+   */
+  get alwaysFilter(): boolean;
+  /**
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * @inheritDoc
+   */
+  canRefill(_blockOrNodeClassName: string, element: HTMLElement): boolean;
+  /**
+   * @inheritDoc
+   */
+  toCssText(): string;
+}

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

@@ -0,0 +1,23 @@
+import { RTEBlock } from '../../blocks/block.abstract';
+import { RTENode } from '../../nodes/node.abstract';
+import { RTEFilterStyles, RTEFilterStylesStrategy } from '../filter-styles-strategy.abstract';
+/**
+ * Filters the default ListAnnotation styles (paddingLeft, marginLeft) from
+ * customStyle when parsing an RTEListBlock.
+ */
+export declare class ListBlockFilterStylesStrategy extends RTEFilterStylesStrategy {
+  protected stylesToBeFiltered: RTEFilterStyles;
+  protected elementTagName: string;
+  /**
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * @inheritDoc
+   */
+  canRefill(blockOrNodeClassName: string, element: HTMLElement): boolean;
+  /**
+   * @inheritDoc
+   */
+  toCssText(): string;
+}

package/dist/types/components/vega-rich-text-editor/dto/filter-styles-strategies/list-block/list-heading-item-block-filter-styles-strategy.d.ts

@@ -0,0 +1,19 @@
+import { RTEBlock } from '../../blocks/block.abstract';
+import { RTENode } from '../../nodes/node.abstract';
+import { HeadingFilterStylesStrategy } from '../text-block/heading-filter-styles-strategy';
+/**
+ * Filters the default heading styles from customStyle when parsing an RTEListItemBlock that is supposed to be a heading.
+ */
+export declare class ListHeadingItemBlockFilterStylesStrategy extends HeadingFilterStylesStrategy {
+  constructor(level: 1 | 2 | 3 | 4 | 5 | 6);
+  /**
+   * Check the important font-size and line-height for list item block are default styles, and the block is a list item block.
+   *
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * @inheritDoc
+   */
+  canRefill(blockOrNodeClassName: string, element: HTMLElement): boolean;
+}

package/dist/types/components/vega-rich-text-editor/dto/filter-styles-strategies/list-block/list-item-block-filter-styles-strategy.d.ts

@@ -0,0 +1,34 @@
+import { RTEBlock } from '../../blocks/block.abstract';
+import { RTENode } from '../../nodes/node.abstract';
+import { RTEFilterStyles, RTEFilterStylesStrategy } from '../filter-styles-strategy.abstract';
+/**
+ * Filters the default paragraph styles from customStyle when parsing an
+ * RTEListItemBlock.  List-item blocks implicitly use paragraph styling,
+ * so these inline defaults are redundant and should not be persisted.
+ */
+export declare class ListItemBlockFilterStylesStrategy extends RTEFilterStylesStrategy {
+  protected stylesToBeFiltered: RTEFilterStyles;
+  protected elementTagName: string;
+  private headingOrTitleClassNamePattern;
+  /**
+   * Check the important font-size for list item block are default styles, and the block is a list item block.
+   *
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * @inheritDoc
+   */
+  canRefill(blockOrNodeClassName: string, element: HTMLElement): boolean;
+  /**
+   * @inheritDoc
+   */
+  toCssText(): string;
+  /**
+   * Check the list item element does not have heading or title class names.
+   *
+   * @param {HTMLElement} element - The list item element to check.
+   * @returns {boolean} - True if the element does not have heading or title class names, false otherwise.
+   */
+  private isElementNotHeadingOrTitle;
+}

package/dist/types/components/vega-rich-text-editor/dto/filter-styles-strategies/list-block/list-title-item-block-filter-styles-strategy.d.ts

@@ -0,0 +1,19 @@
+import { RTEBlock } from '../../blocks/block.abstract';
+import { RTENode } from '../../nodes/node.abstract';
+import { TitleFilterStylesStrategy } from '../text-block/title-filter-styles-strategy';
+/**
+ * Filters the default title/subtitle styles from customStyle when parsing an RTEListItemBlock that is supposed to be a title/subtitle.
+ */
+export declare class ListTitleItemBlockFilterStylesStrategy extends TitleFilterStylesStrategy {
+  constructor(type: 'title' | 'subtitle');
+  /**
+   * Check the important font-size and line-height for list item block are default styles, and the block is a list item block.
+   *
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * @inheritDoc
+   */
+  canRefill(blockOrNodeClassName: string, element: HTMLElement): boolean;
+}

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

@@ -0,0 +1,72 @@
+import { RTEBlock } from '../blocks/block.abstract';
+import { RTENode } from '../nodes/node.abstract';
+/**
+ * Predicate class provides static methods to check specific conditions on HTML elements or dto instances.
+ */
+export declare class Predicate {
+  static RTE_TEXT_NODE_CLASS_NAME: string;
+  static RTE_TEXT_BLOCK_CLASS_NAME: string;
+  /**
+   * Checks if the given class name corresponds to a text block.
+   *
+   * @param {string} className The class name to check.
+   * @returns {boolean} True if the class name corresponds to a text block, false otherwise.
+   */
+  static isTextBlock(className: string): boolean;
+  /**
+   * Checks if the given class name corresponds to a code block.
+   *
+   * @param {string} className The class name to check.
+   * @returns {boolean} True if the class name corresponds to a code block, false otherwise.
+   */
+  static isCodeBlock(className: string): boolean;
+  /**
+   * Checks if the given class name corresponds to a list block.
+   *
+   * @param {string} className The class name to check.
+   * @returns {boolean} True if the class name corresponds to a list block, false otherwise.
+   */
+  static isListBlock(className: string): boolean;
+  /**
+   * Checks if the given class name corresponds to a list item block.
+   *
+   * @param {string} className The class name to check.
+   * @returns {boolean} True if the class name corresponds to a list item block, false otherwise.
+   */
+  static isListItemBlock(className: string): boolean;
+  /**
+   * Checks if the given class name corresponds to a text node.
+   *
+   * @param {string} className The class name to check.
+   * @returns {boolean} True if the class name corresponds to a text node, false otherwise.
+   */
+  static isTextNode(className: string): boolean;
+  /**
+   * Checks if the given block or node instance is a text node and has a link annotation.
+   *
+   * @param {RTEBlock | RTENode} blockOrNodeInstance The block or node instance to check.
+   * @returns {boolean} True if the block or node instance is a text node and has a link annotation, false otherwise.
+   */
+  static isLinkNode(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * Checks if the given block or node instance is a code node, which is defined as a text node that has a code annotation.
+   *
+   * @param {RTEBlock | RTENode} blockOrNodeInstance The block or node instance to check.
+   * @returns {boolean} True if the block or node instance is a code node, false otherwise.
+   */
+  static isCodeNode(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * Check if the given block or node instance is an image node, which is defined as an instance of RTEImageNode.
+   *
+   * @param {RTEBlock | RTENode} blockOrNodeInstance The block or node instance to check.
+   * @returns {boolean} True if the block or node instance is an image node, false otherwise.
+   */
+  static isImageNode(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * Check if the given block or node instance is a code block node, which is defined as an instance of RTECodeBlockNode.
+   *
+   * @param {RTEBlock | RTENode} blockOrNodeInstance The block or node instance to check.
+   * @returns {boolean} True if the block or node instance is a code block node, false otherwise.
+   */
+  static isCodeBlockNode(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+}

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

@@ -0,0 +1,27 @@
+import { VegaRTEAnnotations } from '../../../interface';
+import { RTEFilterStyles, RTEFilterStylesStrategy } from '../filter-styles-strategy.abstract';
+/**
+ * Filters redundant `textAlign` from `customStyle` when parsing blocks that carry
+ * a semantic `textAlign` annotation (RTETextBlock, RTEListBlock, RTEListItemBlock).
+ *
+ * During source-to-normal round-trips the `HorizontalAlignmentAnnotation` emits
+ * `text-align` as an inline style (standalone mode), and `CustomStyleAnnotationHandler`
+ * captures it into `customStyle`.  This strategy removes the duplicate so the
+ * semantic annotation is the single source of truth.
+ */
+export declare class AlignmentFilterStylesStrategy extends RTEFilterStylesStrategy {
+  protected stylesToBeFiltered: RTEFilterStyles;
+  /**
+   * @returns {boolean} Always `true` — alignment inline styles are always emitted
+   * in standalone/source-edit mode, so the duplicate is always safe to remove.
+   */
+  get alwaysFilter(): boolean;
+  /**
+   * Removes `textAlign` from `customStyle` when it duplicates the value returned
+   * by `HorizontalAlignmentAnnotation.getDefaultStyles(textAlign)`.
+   *
+   * @param {VegaRTEAnnotations} annotations - The annotations object (mutated in place).
+   * @returns {VegaRTEAnnotations} The same annotations reference.
+   */
+  filterAnnotations(annotations: VegaRTEAnnotations): VegaRTEAnnotations;
+}

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

@@ -0,0 +1,10 @@
+import { VegaRTETextStyleType } from '../../../interface';
+import { ParagraphFilterStylesStrategy } from './paragraph-filter-styles-strategy';
+/**
+ * The HeadingFilterStylesStrategy class is responsible for filtering and refilling styles for heading text blocks (h1 to h6) in the rich text editor.
+ */
+export declare class HeadingFilterStylesStrategy extends ParagraphFilterStylesStrategy {
+  protected type: VegaRTETextStyleType;
+  protected elementTagName: string;
+  constructor(level: 1 | 2 | 3 | 4 | 5 | 6);
+}

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

@@ -0,0 +1,34 @@
+import { VegaRTEAnnotations, VegaRTETextStyleType } from '../../../interface';
+import type { RTEBlock } from '../../blocks/block.abstract';
+import type { RTENode } from '../../nodes/node.abstract';
+import { RTEFilterStyles, RTEFilterStylesStrategy } from '../filter-styles-strategy.abstract';
+/**
+ *
+ */
+export declare class ParagraphFilterStylesStrategy extends RTEFilterStylesStrategy {
+  protected stylesToBeFiltered: RTEFilterStyles;
+  protected type: VegaRTETextStyleType;
+  protected elementTagName: string;
+  /**
+   * Don't run the filterAnnotations for paragraph heading, title, subtitle, list heading item, list title item, list subtitle item.
+   * Already handle it in html-element-to-annotation-generator.ts#removeTextStyleDefaultsFromCustomStyle
+   *
+   * @inheritDoc
+   */
+  filterAnnotations(annotations: VegaRTEAnnotations): VegaRTEAnnotations;
+  /**
+   * Determines whether the dto instance is text block and has the same type as the strategy's configured type.
+   *
+   * @param {RTEBlock | RTENode} blockOrNodeInstance - The block or node instance to check.
+   * @returns {boolean} - True if the instance is a text block with the same type as the strategy, false otherwise.
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * @inheritDoc
+   */
+  canRefill(blockOrNodeClassName: string, element: HTMLElement): boolean;
+  /**
+   * @inheritDoc
+   */
+  toCssText(): string;
+}

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

@@ -0,0 +1,11 @@
+import { VegaRTETextStyleType } from '../../../interface';
+import { ParagraphFilterStylesStrategy } from './paragraph-filter-styles-strategy';
+/**
+ * The TitleFilterStylesStrategy class is responsible for filtering and refilling styles for title and subtitle text blocks in the rich text editor.
+ */
+export declare class TitleFilterStylesStrategy extends ParagraphFilterStylesStrategy {
+  protected type: VegaRTETextStyleType;
+  protected elementTagName: string;
+  protected classNameToBeAdded: string;
+  constructor(titleType: 'title' | 'subtitle');
+}

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

@@ -0,0 +1,40 @@
+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 CodeFilterStylesStrategy is responsible for filtering code styles from text nodes that are annotated as code.
+ */
+export declare class CodeFilterStylesStrategy extends RTEFilterStylesStrategy {
+  protected stylesToBeFiltered: RTEFilterStyles;
+  protected elementTagName: string;
+  /**
+   * Only strips code-default styles when the `code` annotation is present,
+   * so that a user-applied `fontFamily: 'Roboto Mono'` without code is preserved.
+   *
+   * @param {VegaRTEAnnotations} annotations - The annotations object (mutated in place).
+   * @returns {VegaRTEAnnotations} The same annotations reference.
+   */
+  filterAnnotations(annotations: VegaRTEAnnotations): VegaRTEAnnotations;
+  /**
+   * Determines whether the dto instance is a code text node.
+   *
+   * @param {RTEBlock | RTENode} blockOrNodeInstance - The block or node instance to check.
+   * @returns {boolean} - True if the instance is a code text node, false otherwise.
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * Check if the node is a text node and it is a code node.
+   *
+   * @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 it a code element.
+   */
+  canRefill(blockOrNodeClassName: string, element: HTMLElement): boolean;
+  /**
+   * The code style in title and heading no need to be bold in default.
+   *
+   * @returns {string} The CSS text string for code styles.
+   */
+  toCssText(): string;
+}

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

@@ -0,0 +1,37 @@
+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';
+/**
+ * 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.
+   *
+   * @param {VegaRTEAnnotations} annotations - The annotations to filter.
+   * @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/text-format-filter-styles-strategy.d.ts

@@ -0,0 +1,41 @@
+import { VegaRTEAnnotations } from '../../../interface';
+import { RTEFilterStyles, RTEFilterStylesStrategy } from '../filter-styles-strategy.abstract';
+/**
+ * Filters redundant inline text formatting styles from `customStyle` when
+ * parsing an RTETextNode. These styles are already represented by semantic
+ * annotations and should not be persisted as custom overrides after source
+ * edit round-trips.
+ */
+export declare class TextFormatFilterStylesStrategy extends RTEFilterStylesStrategy {
+  protected stylesToBeFiltered: RTEFilterStyles;
+  /**
+   * @returns {boolean} Always `true` — this strategy runs regardless of `autoMatchFormat`.
+   */
+  get alwaysFilter(): boolean;
+  /**
+   * Filter redundant text format styles from `customStyle`.
+   *
+   * @param {VegaRTEAnnotations} annotations - The annotations to filter.
+   * @returns {VegaRTEAnnotations} The same annotations reference with customStyle cleaned up.
+   */
+  filterAnnotations(annotations: VegaRTEAnnotations): VegaRTEAnnotations;
+  /**
+   * Normalizes a `text-decoration` CSS value to a sorted, unique token string of
+   * toolbar-only tokens (`underline`, `line-through`). Returns `undefined` if the
+   * value contains any non-toolbar token (e.g. `wavy`, a color).
+   *
+   * @param {string | undefined} value - The raw `textDecoration` CSS value.
+   * @returns {string | undefined} Normalized token string, or `undefined` if the value cannot be safely removed.
+   */
+  private normalizeTextDecoration;
+  /**
+   * Determines whether the `textDecoration` custom style should be removed based on the
+   * semantic annotations present. Removal happens only when the normalized value exactly
+   * matches the set of `{underline, strikethrough}` annotations.
+   *
+   * @param {string} normalizedTextDecoration - The normalized `textDecoration` token string.
+   * @param {VegaRTETextAnnotations} annotations - The text annotations to check against.
+   * @returns {boolean} `true` if the `textDecoration` style is redundant and should be removed.
+   */
+  private shouldRemoveTextDecoration;
+}

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