@heartlandone/vega 2.80.0 → 2.81.0

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

@@ -3,3 +3,8 @@ export declare const RTE_DEFAULT_TEXT_COLOR: VegaRTEColorSchema;
 export declare const RTE_TEXT_COLORS: VegaRTEColorSchema[];
 export declare const ZERO_WIDTH_SPACE: string;
 export declare const VegaRTEPresetToolbarItems: VegaRTEToolbarItem[][];
+/**
+ * Void/self-closing HTML elements that have no closing tag and cannot contain children.
+ * Source: https://html.spec.whatwg.org/multipage/syntax.html#void-elements
+ */
+export declare const HTML_VOID_TAGS: Set<string>;

package/dist/types/components/vega-rich-text-editor/dto/annotations/image-annotation.d.ts

@@ -6,6 +6,7 @@ import { VegaRichTextImageEditorSizeType } from '../../vega-rich-text-image-edit
  * Annotation for image
  */
 export declare class ImageAnnotation extends NodeAnnotation {
+  static BASE_STYLES: AnnotationStyle;
   readonly type: NodeAnnotationTypeEnum;
   size: Nullable<VegaRichTextImageEditorSizeType>;
   alt: string;

package/dist/types/components/vega-rich-text-editor/dto/annotations/inline-html-annotation.d.ts

@@ -14,6 +14,14 @@ export declare class InlineHtmlAnnotation extends Annotation {
   customAttribute?: CustomAttributeAnnotation;
   customClass?: CustomClassAnnotation;
   customStyle?: CustomStyleAnnotation;
+  /**
+   * Shared identifier assigned to all text nodes that belong to the same outer
+   * inline-HTML wrapper at a given nesting depth.  Used at render time by
+   * {@link RTETextBlock.renderGroupedNodesAtDepth} to re-merge adjacent siblings back
+   * into a single wrapper element, reversing the flattening introduced during
+   * parsing.
+   */
+  groupId?: string;
   constructor(htmlTag: string);
   /**
    * Generate the map item for the annotation
@@ -28,6 +36,12 @@ export declare class InlineHtmlAnnotation extends Annotation {
    * @returns {InlineHtmlAnnotation} - Inline HTML annotation
    */
   clone(): InlineHtmlAnnotation;
+  /**
+   * Build the props object used when rendering this annotation.
+   *
+   * @returns {Record<string, unknown>} Props for h(tag, props, children).
+   */
+  renderProps(): Record<string, unknown>;
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/types/components/vega-rich-text-editor/dto/annotations/link-group-annotation.d.ts

@@ -2,10 +2,15 @@ import { Annotation, InternalAnnotationTypeEnum } from './annotation.abstract';
 import { RTETextNode } from '../nodes/text-node';
 import { AnnotationStyle, RTERenderContext } from '../../interface';
 import { LinkAnnotation } from './link-annotation';
+import { LinkFilterStylesStrategy } from '../filter-styles-strategies/text-node/link-filter-styles-strategy';
+declare type LinkGroupConversionOptions = RTERenderContext & {
+  filterInlineStyles?: boolean;
+};
 /**
  * Annotation to represent a link of grouped nodes
  */
 export declare class LinkGroupAnnotation extends Annotation {
+  static linkGroupFilterStylesStrategy: LinkFilterStylesStrategy;
   readonly type: InternalAnnotationTypeEnum;
   linkGroups: Map<string, RTETextNode[]>;
   constructor(groupKey: string);
@@ -21,10 +26,10 @@ export declare class LinkGroupAnnotation extends Annotation {
    * Convert the custom style, class and attribute to string which html can used
    *
    * @param {linkAnnotation} linkAnnotation current link annotation which saved custom style, class and attribute.
-   * @param {RTERenderContext} options - options.
+   * @param {LinkGroupConversionOptions} options - options.
    * @returns {string} - string.
    */
-  toString(linkAnnotation: LinkAnnotation, options?: RTERenderContext): string;
+  toString(linkAnnotation: LinkAnnotation, options?: LinkGroupConversionOptions): string;
   /**
    * Convert the custom style, class and attribute to JSX attributes
    *
@@ -64,3 +69,4 @@ export declare class LinkGroupAnnotation extends Annotation {
    */
   private formatStyleToString;
 }
+export {};

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

@@ -119,10 +119,11 @@ export declare abstract class RTEBlock<P = RTEBlockParentType, C = RTEBlockChild
   /**
    * Generate attributes as string
    *
+   * @param {VegaRTETransformOptions} options - Options to control the generation of the attribute string, such as whether to filter inline styles.
    * @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 action to block
    *
@@ -157,9 +158,10 @@ export declare abstract class RTEBlock<P = RTEBlockParentType, C = RTEBlockChild
   /**
    * Converts the block to HTML.
    *
+   * @param {VegaRTETransformOptions} options - Optional conversion options.
    * @returns {string} The HTML string representing the block.
    */
-  abstract toHtml(): string;
+  abstract toHtml(options?: VegaRTETransformOptions): string;
   /**
    * Clones the block.
    *

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

@@ -1,4 +1,4 @@
-import { RTEBlockType, VegaRTECodeBlock } from '../../interface';
+import { RTEBlockType, VegaRTECodeBlock, VegaRTETransformOptions } from '../../interface';
 import { VegaRTEContent } from '../content-state';
 import { RTENode } from '../nodes/node.abstract';
 import { RTEBlock } from './block.abstract';
@@ -29,7 +29,7 @@ export declare class RTECodeBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock
   /**
    * @inheritDoc
    */
-  toHtml(): string;
+  toHtml(options?: VegaRTETransformOptions): string;
   /**
    * @inheritDoc
    */

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

@@ -6,16 +6,6 @@ import { RTENode } from '../nodes/node.abstract';
  * HTML Block
  */
 export declare class RTEHtmlBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock, RTEBlock> {
-  /**
-   * Void/self-closing tags that don't have closing tags and don't contain children.
-   * These tags should be rendered as <tag> or <tag/> instead of <tag></tag>.
-   *
-   * Based on canHandleTags from html-block-strategy.ts, the following are void tags:
-   * - HR: horizontal rule
-   * - INPUT: form input
-   * - COL: table column
-   */
-  private static readonly VOID_TAGS;
   type: 'html-block';
   parent: VegaRTEContent | RTEHtmlBlock;
   htmlTag: string;
@@ -44,7 +34,7 @@ export declare class RTEHtmlBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock
   /**
    * @inheritDoc
    */
-  toHtml(): string;
+  toHtml(options?: VegaRTETransformOptions): string;
   /**
    * @inheritDoc
    */

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

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

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;
+}