@heartlandone/vega 2.80.0 → 2.82.0

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

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

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

@@ -30,7 +30,7 @@ export declare class RTEListItemBlock extends RTETextBlock {
   /**
    * @inheritDoc
    */
-  toHtml(): string;
+  toHtml(options?: VegaRTETransformOptions): string;
   /**
    * @inheritDoc
    */

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

@@ -56,7 +56,7 @@ export declare class RTETextBlock extends RTEBlock<VegaRTEContent | RTEListBlock
   /**
    * @inheritDoc
    */
-  toHtml(): string;
+  toHtml(options?: VegaRTETransformOptions): string;
   /**
    * Clone the nodes to a new block
    *
@@ -85,18 +85,31 @@ export declare class RTETextBlock extends RTEBlock<VegaRTEContent | RTEListBlock
   /**
    * Get the HTML string for the children nodes, including handling link group annotations.
    *
+   * @param {VegaRTETransformOptions} [options] - Optional conversion options that may affect how the children nodes are rendered as HTML.
    * @returns {string} The HTML string representing the children nodes.
    */
-  getChildrenHtml(): string;
+  getChildrenHtml(options?: VegaRTETransformOptions): string;
   /**
    * @inheritDoc
    */
   protected doAnnotationActionApply(action: AnnotationAction): void;
+  /**
+   * Recursively groups `nodes` by their inline HTML wrapper at the given
+   * `depth`, emitting shared wrappers for adjacent siblings with the same
+   * `groupId` and descending into the next depth for each group.
+   *
+   * @param {RTETextNode[]} nodes - The nodes to render.
+   * @param {number} depth - Current depth in the inline HTML chain (0 = outermost).
+   * @param {VegaRTETransformOptions} [options] - Optional conversion options.
+   * @returns {string} HTML string with grouped wrappers at this depth.
+   */
+  private renderGroupedNodesAtDepth;
   /**
    * Generate Link Html
    *
    * @param {LinkGroupAnnotation} linkGroupAnnotation - linkGroupAnnotation
    * @param {string} nodesHtml - The nodes html
+   * @param {VegaRTETransformOptions} [options] - Optional conversion options that may affect how the children nodes are rendered as HTML.
    * @returns {string} link html
    */
   private generateLinkHtml;

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

@@ -1,4 +1,4 @@
-import { RTEContentBlock, VegaRTEContentBlock, ListType, VegaRTETransformOptions } from '../interface';
+import { RTEContentBlock, VegaRTEContentBlock, ListType, VegaRTETransformOptions, VegaRTEGenerateStyleOptions } from '../interface';
 import { RTEListBlock } from './blocks/list-block';
 import type { RTETextBlock } from './blocks/text-block';
 import { ModifyContentAction } from './actions/modify-content-action.abstract';
@@ -35,6 +35,13 @@ export declare class VegaRTEContent {
    * @returns {VegaRTEContent} The converted content state.
    */
   static fromHtml(html: string, options?: VegaRTETransformOptions): VegaRTEContent;
+  /**
+   * Generates the content style file for the rich text editor based on the registered filter styles strategies.
+   *
+   * @param {VegaRTEGenerateStyleOptions} options - Options for generating the content style file.
+   * @returns {string} The html template style text.
+   */
+  static generateContentStyles(options?: VegaRTEGenerateStyleOptions): string;
   /**
    * Clones the content state.
    *
@@ -51,8 +58,7 @@ export declare class VegaRTEContent {
   /**
    * Converts the content state to HTML.
    *
-   * @deprecated The [`options`]{@link options} parameter is deprecated and will be removed in the future.
-   * @param {VegaRTETransformOptions} [options] - Deprecated. Optional rendering context (currently unused).
+   * @param {VegaRTETransformOptions} [options] - The conversion options.
    * @returns {string} The HTML representation of the content state.
    */
   toHtml(options?: VegaRTETransformOptions): string;

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

@@ -0,0 +1,27 @@
+import { RTEBlock } from '../../blocks/block.abstract';
+import { RTENode } from '../../nodes/node.abstract';
+import { RTEFilterStyles, RTEFilterStylesStrategy } from '../filter-styles-strategy.abstract';
+/**
+ * Filter styles strategy for code block, which defines the styles to be filtered and the conditions for filtering and refilling styles for code blocks.
+ */
+export declare class CodeBlockFilterStylesStrategy extends RTEFilterStylesStrategy {
+  static STYLES: RTEFilterStyles;
+  protected stylesToBeFiltered: RTEFilterStyles;
+  protected elementTagName: string;
+  /**
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * The code block styles is preset and will convert to vega-code-block element so we don't need to to refill styles back to element.
+   *
+   * @param {string} _blockOrNodeClassName The class name of the block or node.
+   * @param {HTMLElement} _element The HTML element to check.
+   * @returns {boolean} False, as we don't need to refill styles for code blocks.
+   */
+  canRefill(_blockOrNodeClassName: string, _element: HTMLElement): boolean;
+  /**
+   * @inheritDoc
+   */
+  toCssText(): string;
+}

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

@@ -0,0 +1,27 @@
+import { RTEBlock } from '../../blocks/block.abstract';
+import { RTENode } from '../../nodes/node.abstract';
+import { RTEFilterStyles, RTEFilterStylesStrategy } from '../filter-styles-strategy.abstract';
+/**
+ * Filter styles strategy for code block node, which defines the styles to be filtered and the conditions for filtering and refilling styles for code block nodes.
+ */
+export declare class CodeBlockNodeFilterStylesStrategy extends RTEFilterStylesStrategy {
+  static STYLES: RTEFilterStyles;
+  protected stylesToBeFiltered: RTEFilterStyles;
+  protected elementTagName: string;
+  /**
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * The code node styles is preset and will convert to vega-code-block element so we don't need to to refill styles back to element.
+   *
+   * @param {string} _blockOrNodeClassName The class name of the block or node.
+   * @param {HTMLElement} _element The HTML element to check.
+   * @returns {boolean} False, as we don't need to refill styles for code nodes.
+   */
+  canRefill(_blockOrNodeClassName: string, _element: HTMLElement): boolean;
+  /**
+   * @inheritDoc
+   */
+  toCssText(): string;
+}

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

@@ -1,4 +1,7 @@
-import { RTEFilterStylesStrategy } from './filter-styles-strategy.abstract';
+import { RTEFilterInlineStylesResult } from '../../interface';
+import { RTEBlock } from '../blocks/block.abstract';
+import { RTENode } from '../nodes/node.abstract';
+import { RTEFilterStyles, RTEFilterStylesStrategy } from './filter-styles-strategy.abstract';
 /**
  * Registry for managing filter styles strategies keyed by DTO class name.
  *
@@ -25,4 +28,27 @@ export declare class RTEFilterStylesStrategyRegistry {
    * @returns {RTEFilterStylesStrategy[]} Registered strategies (empty array if none).
    */
   static getStrategies(dtoClassName: string): RTEFilterStylesStrategy[];
+  /**
+   * Executes the appropriate filter styles strategy for a given block or node instance.
+   *
+   * @param {RTEBlock | RTENode} blockOrNodeInstance - The block or node instance to filter styles for.
+   * @param {RTEFilterStyles} styles - The full set of styles to filter.
+   * @param {string[]} classNames - The class names to consider.
+   * @returns {RTEFilterInlineStylesResult} The result of filtering, including the remaining styles and class names.
+   */
+  static executeTheStrategyFilterAction(blockOrNodeInstance: RTEBlock | RTENode, styles: RTEFilterStyles, classNames: string[]): RTEFilterInlineStylesResult;
+  /**
+   * Executes the appropriate filter styles strategy for refilling styles on a given element.
+   *
+   * @param {string} dtoClassName The class name of the DTO.
+   * @param {HTMLElement} element The HTML element to refill styles on.
+   */
+  static executeTheStrategyRefillAction(dtoClassName: string, element: HTMLElement): void;
+  /**
+   * Based on the registered strategies, generates the CSS text for all strategies in the registry. The generated CSS text is grouped by DTO class names for better organization.
+   *
+   * @param {boolean} enableFontFaceImports - A flag indicating whether to include font-face declarations for typography styles.
+   * @returns {string} The content of style file.
+   */
+  static generateAllStylesContent(enableFontFaceImports?: boolean): string;
 }

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

@@ -1,5 +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.
@@ -10,11 +13,68 @@ 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
@@ -22,18 +82,11 @@ export declare abstract class RTEFilterStylesStrategy {
    * `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 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;
   /**
    * Removes configured default style properties from the target styles object.
    * Only properties whose value matches the configured default exactly are deleted.
@@ -42,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

@@ -1,10 +1,28 @@
+import { RTEBlock } from '../../blocks/block.abstract';
+import { RTENode } from '../../nodes/node.abstract';
 import { RTEFilterStyles, RTEFilterStylesStrategy } from '../filter-styles-strategy.abstract';
 /**
- * Filters the default ImageAnnotation base styles (verticalAlign) from
- * customStyle when parsing an RTEImageNode.
+ * 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;
-  /** @returns {boolean} Always `true` — image defaults are emitted as inline styles. */
+  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

@@ -1,3 +1,5 @@
+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
@@ -5,4 +7,17 @@ import { RTEFilterStyles, RTEFilterStylesStrategy } from '../filter-styles-strat
  */
 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

@@ -1,3 +1,5 @@
+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
@@ -6,4 +8,27 @@ import { RTEFilterStyles, RTEFilterStylesStrategy } from '../filter-styles-strat
  */
 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/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

@@ -1,11 +1,13 @@
 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';
 /**
- * Filters the default CodeAnnotation styles (fontFamily, whiteSpace) from
- * customStyle when parsing an RTETextNode that has a `code` annotation.
+ * 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.
@@ -14,4 +16,25 @@ export declare class CodeFilterStylesStrategy extends RTEFilterStylesStrategy {
    * @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;
 }