@heartlandone/vega 2.78.0 → 2.79.0

package/dist/types/components/vega-calendar/slimmers/common/controllers/vega-calendar-day-view-focus-slimmer.d.ts

@@ -0,0 +1,15 @@
+import { AutoRunWhenReRenderTaskQueueSlimmer } from '../../../../../helpers/slimmers/auto-run-when-re-render-task-queue-slimmer.abstract';
+/**
+ * The `VegaCalendarDayViewFocusSlimmer` class is a slimmer that focuses on the day view title element of a calendar component after the component has been re-rendered. It extends the `AutoRunWhenReRenderTaskQueueSlimmer` class, which allows it to schedule a task to be executed after the component has been updated.
+ */
+export declare class VegaCalendarDayViewFocusSlimmer extends AutoRunWhenReRenderTaskQueueSlimmer {
+  private host;
+  /**
+   * Schedule a task to focus on the day view title element after the component has been re-rendered.
+   */
+  scheduleFocus(): void;
+  /**
+   * The `doTask` method is called after the component has been re-rendered. It focuses on the day view title element in the calendar component's shadow DOM.
+   */
+  protected doTask(): Promise<void>;
+}

package/dist/types/components/vega-calendar/slimmers/month-view/renderers/vega-calendar-month-view-renderer.d.ts

@@ -12,6 +12,8 @@ export declare class VegaCalendarMonthViewRenderer extends VegaCalendarDateBlock
   protected isDateDisabled: VegaCalendar['isDateDisabled'];
   protected showSwitchView: VegaCalendar['showSwitchView'];
   protected timezone: VegaCalendar['timezone'];
+  protected host: VegaCalendar['host'];
+  protected dayViewFocusSlimmer: VegaCalendar['dayViewFocusSlimmer'];
   /**
    * the HTML elements that represent the month view of a calendar component.
    *
@@ -42,6 +44,7 @@ export declare class VegaCalendarMonthViewRenderer extends VegaCalendarDateBlock
    * switch to current date day view
    *
    * @param {CalendarDate} calendarDate the calendar date object
+   * @param {MouseEvent} e the mouse event object
    */
   private goToCurrentDayView;
   /**

package/dist/types/components/vega-calendar/vega-calendar-event-preview/slimmers/renderers/vega-calendar-event-preview-detail-renderer.d.ts

@@ -4,6 +4,7 @@ export declare class VegaCalendarEventPreviewDetailRenderer extends VegaSlimmer
   protected host: VegaCalendarEventPreview['host'];
   protected previewPayload: VegaCalendarEventPreview['previewPayload'];
   protected currentEvent: VegaCalendarEventPreview['currentEvent'];
+  protected translationSlimmer: VegaCalendarEventPreview['translationSlimmer'];
   private calendarRef;
   componentWillLoad(): void;
   render(): HTMLElement;

package/dist/types/components/vega-calendar/vega-calendar.d.ts

@@ -30,6 +30,7 @@ import { VegaCalendarTimeMarkerRenderer } from './slimmers/day-view/renderers/ve
 import { VegaCalendarPostOperationDateController } from './slimmers/common/controllers/vega-calendar-post-operation-date-controller';
 import { VegaCalendarEventPreviewPopoverRenderer } from './slimmers/common/renderers/vega-calendar-event-preview-popover-renderer';
 import { VegaCalendarEventPreviewPopoverController } from './slimmers/common/controllers/vega-calendar-event-preivew-popover-controller';
+import { VegaCalendarDayViewFocusSlimmer } from './slimmers/common/controllers/vega-calendar-day-view-focus-slimmer';
 /**
  * @vegaVersion 2.14.0
  */
@@ -39,6 +40,7 @@ export declare class VegaCalendar {
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaCalendarElement>;
   protected renderer: VegaCalendarRenderer;
   protected switchPanelRenderer: VegaCalendarSwitchPanelRenderer;
+  protected dayViewFocusSlimmer: VegaCalendarDayViewFocusSlimmer;
   protected viewRenderer: VegaCalendarViewRenderer;
   protected monthViewRenderer: VegaCalendarMonthViewRenderer;
   protected viewWithTimeRenderer: VegaCalendarViewWithTimeRenderer;

package/dist/types/components/vega-date-picker/slimmers/controllers/vega-date-picker-calendar-open-state-controller.d.ts

@@ -1,5 +1,6 @@
 import { VegaDatePicker } from '../../vega-date-picker';
 import { ElementAppenderSlimmer } from '../../../../helpers/slimmers/element-appender/element-appender-slimmer';
+import { AriaDialogFocusableTrapSlimmer } from '../../../../helpers/slimmers/aria-dialog-focusable-trap-slimmer';
 /** The date picker element appender controller slimmer */
 export declare class VegaDatePickerCalendarOpenStateController extends ElementAppenderSlimmer {
   dropdownConfig: VegaDatePicker['dropdownConfig'];
@@ -10,6 +11,7 @@ export declare class VegaDatePickerCalendarOpenStateController extends ElementAp
   mode: VegaDatePicker['mode'];
   isCalendarShow: VegaDatePicker['isCalendarShow'];
   isMobileDevice: VegaDatePicker['isMobileDevice'];
+  protected readonly ariaDialogFocusableTrapSlimmer: AriaDialogFocusableTrapSlimmer;
   private clearCalendarStateTaskQueue;
   /**
    * Since connectedCallback will init element appender again, and it will add `vega-force-hidden` class to calendar,

package/dist/types/components/vega-date-picker/slimmers/renderers/vega-date-picker-calendar-renderer.d.ts

@@ -18,15 +18,20 @@ export declare class VegaDatePickerCalendarRenderer extends VegaSlimmer {
   isCalendarShow: VegaDatePicker['isCalendarShow'];
   isDateDisabled: VegaDatePicker['isDateDisabled'];
   allowRepick: VegaDatePicker['allowRepick'];
+  disabled: VegaDatePicker['disabled'];
+  label: VegaDatePicker['label'];
   monthYearChangeEventEmitter: VegaDatePicker['monthYearChangeEventEmitter'];
+  translationSlimmer: VegaDatePicker['translationSlimmer'];
   vegaDatePickerValueController: VegaDatePicker['vegaDatePickerValueController'];
   calendarOpenStateController: VegaDatePicker['calendarOpenStateController'];
+  private readonly calendarId;
   private calendarContentBoxRef;
   private calendarRef;
   private mobileModalRef;
   componentDidLoad(): void;
   getCalendarContentBoxRef(): HTMLVegaBoxElement;
   getCalendarRef(): HTMLVegaDatePickerCalendarElement;
+  getCalendarId(): string;
   getMobileModalRef(): HTMLVegaModalElement;
   triggerRepick(type: DatePickerCalendarRepickType): Promise<void>;
   render(): HTMLElement;

package/dist/types/components/vega-date-picker/slimmers/renderers/vega-date-picker-input-renderer-base.abstract.d.ts

@@ -7,6 +7,7 @@ export declare abstract class VegaDatePickerInputRendererBase extends VegaSlimme
   disabled: VegaDatePicker['disabled'];
   showClearIcon: VegaDatePicker['showClearIcon'];
   mode: VegaDatePicker['mode'];
+  isCalendarShow: VegaDatePicker['isCalendarShow'];
   vegaDatePickerValueController: VegaDatePicker['vegaDatePickerValueController'];
   calendarOpenStateController: VegaDatePicker['calendarOpenStateController'];
   /**
@@ -15,4 +16,5 @@ export declare abstract class VegaDatePickerInputRendererBase extends VegaSlimme
   protected renderClearIcon(): HTMLElement;
   private onClickClearIcon;
   private isClearIconVisible;
+  abstract focusInput(): void;
 }

package/dist/types/components/vega-date-picker/slimmers/renderers/vega-date-picker-range-input-renderer.d.ts

@@ -2,6 +2,8 @@ import { VegaDatePicker } from '../../vega-date-picker';
 import { VegaDatePickerInputRendererBase } from './vega-date-picker-input-renderer-base.abstract';
 export declare class VegaDatePickerRangeInputRenderer extends VegaDatePickerInputRendererBase {
   placeholder: VegaDatePicker['placeholder'];
+  label: VegaDatePicker['label'];
+  isCalendarShow: VegaDatePicker['isCalendarShow'];
   vegaDatePickerFormatController: VegaDatePicker['vegaDatePickerFormatController'];
   vegaDatePickerRenderer: VegaDatePicker['vegaDatePickerRenderer'];
   calendarOpenStateController: VegaDatePicker['calendarOpenStateController'];
@@ -13,6 +15,7 @@ export declare class VegaDatePickerRangeInputRenderer extends VegaDatePickerInpu
   private endDateInputRef;
   getStartDateInputRef(): HTMLInputElement;
   getEndDateInputRef(): HTMLInputElement;
+  focusInput(): void;
   render: () => HTMLElement;
   private getRangePlaceholder;
   /**

package/dist/types/components/vega-date-picker/slimmers/renderers/vega-date-picker-single-input-renderer.d.ts

@@ -3,11 +3,16 @@ import { VegaDatePickerInputRendererBase } from './vega-date-picker-input-render
 export declare class VegaDatePickerSingleInputRenderer extends VegaDatePickerInputRendererBase {
   placeholder: VegaDatePicker['placeholder'];
   format: VegaDatePicker['format'];
+  label: VegaDatePicker['label'];
+  isCalendarShow: VegaDatePicker['isCalendarShow'];
   vegaDatePickerFormatController: VegaDatePicker['vegaDatePickerFormatController'];
   vegaDatePickerRenderer: VegaDatePicker['vegaDatePickerRenderer'];
   calendarOpenStateController: VegaDatePicker['calendarOpenStateController'];
+  vegaDatePickerCalendarRenderer: VegaDatePicker['vegaDatePickerCalendarRenderer'];
+  translationSlimmer: VegaDatePicker['translationSlimmer'];
   private singleDateInputRef;
   getSingleDateInputRef(): HTMLInputElement;
+  focusInput(): void;
   render: () => HTMLElement;
   private getSinglePlaceholder;
   /**

package/dist/types/components/vega-grid/vega-grid.d.ts

@@ -1,4 +1,4 @@
-import { ResponsiveType, GridRowsType, GridColumnsType, GapType } from '../../types/ui.type';
+import { ResponsiveType, GridRowsType, GridColumnsType, GapType, GridJustifyItemsType } from '../../types/ui.type';
 import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 /**
@@ -62,5 +62,17 @@ export declare class VegaGrid {
    * @vegaVersion 1.3.0
    */
   gap: ResponsiveType<GapType>;
+  /**
+   * Specifies how grid items are aligned along the inline (row) axis.
+   *
+   * It can be provided as one of: `start`, `center`, `end`, or `stretch`.
+   *
+   * Alternatively, you can use a responsive map to define different values for
+   *    various breakpoints. The keys in the map should represent the breakpoints,
+   *    such as `default` or `L`.
+   *
+   * @vegaVersion 2.79.0
+   */
+  justifyItems: ResponsiveType<GridJustifyItemsType>;
   render(): VegaGrid;
 }

package/dist/types/components/vega-input/slimmers/renderers/vega-input-input-renderer.d.ts

@@ -8,6 +8,7 @@ export declare class VegaInputInputRenderer extends VegaSlimmer {
   private name;
   private autocomplete;
   private inputmode;
+  private readOnly;
   private placeholder;
   private minLength;
   private maxLength;

package/dist/types/components/vega-input/vega-input.d.ts

@@ -192,6 +192,16 @@ export declare class VegaInput {
    * @vegaVersion 2.71.0
    */
   inputmode: 'text' | 'numeric';
+  /**
+   * Sets the input field as read-only, preventing direct keyboard input.
+   *
+   * When set to `true`, prevents manual keyboard text entry in the input field on
+   *    all platforms. On touch devices, this typically suppresses the virtual keyboard.
+   *
+   * @default false
+   * @vegaVersion 2.79.0
+   */
+  readOnly: boolean;
   /**
    * Displays a Vega icon at the leading (left) side of the input field,
    * providing visual context about the expected input.

package/dist/types/components/vega-modal/slimmers/controllers/vega-modal-open-state-controller.d.ts

@@ -2,6 +2,7 @@ import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
 import { VegaModal } from '../../vega-modal';
 import type { VegaModalOpenStateChangeTrigger } from '../../types';
 import { VegaModalOpenState } from '../models/vega-modal-open-state';
+import { AriaDialogFocusableTrapSlimmer } from '../../../../helpers/slimmers/aria-dialog-focusable-trap-slimmer';
 /**
  * Modal open state controller
  */
@@ -17,6 +18,8 @@ export declare class VegaModalOpenStateController extends VegaSlimmer {
   backdropController: VegaModal['backdropController'];
   openedModalStackController: VegaModal['openedModalStackController'];
   zIndexController: VegaModal['zIndexController'];
+  renderer: VegaModal['renderer'];
+  protected readonly ariaDialogFocusableTrapSlimmer: AriaDialogFocusableTrapSlimmer;
   private backdropMouseDownOnHost;
   private backdropMouseUpOnHost;
   /**
@@ -27,6 +30,10 @@ export declare class VegaModalOpenStateController extends VegaSlimmer {
    * Component lifecycle - [componentDidLoad]
    */
   componentDidLoad(): void;
+  /**
+   * Component lifecycle - [componentDidRender]
+   */
+  componentDidRender(): void;
   /**
    * Toggle modal while openState changed.
    *
@@ -76,6 +83,12 @@ export declare class VegaModalOpenStateController extends VegaSlimmer {
    * @param {VegaModalOpenStateChangeTrigger} trigger - Indicates what initiated the close.
    */
   close(trigger: VegaModalOpenStateChangeTrigger): void;
+  /**
+   * Toggles the aria-dialog attribute based on the open state.
+   *
+   * @param {boolean} isOpen - Indicates whether the modal is open.
+   */
+  ariaDialogToggle(isOpen: boolean): void;
   /**
    * Updates the internal open state snapshot so watchers can react to the new value.
    *

package/dist/types/components/vega-modal/slimmers/renderers/vega-modal-renderer.d.ts

@@ -15,6 +15,7 @@ export declare class VegaModalRenderer extends VegaSlimmer {
   handleClose: VegaModal['handleClose'];
   deprecatedPropertySlimmer: VegaModal['deprecatedPropertySlimmer'];
   openStateController: VegaModal['openStateController'];
+  private readonly titleId;
   private modalContent;
   private modalFooter;
   private modalContainer;

package/dist/types/components/vega-popover/slimmers/controllers/vega-popover-appender-controller.d.ts

@@ -32,6 +32,7 @@ export declare class VegaPopoverAppenderController extends ElementAppenderSlimme
   private generateShowConfigFactory;
   /**
    * Register a remote method to update the target element of the popover.
+   * TODO: refactor to using Change Manager
    */
   private registerRemoteMethod;
 }

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

@@ -5,6 +5,7 @@ import { VegaRTEContent } from '../vega-rich-text-editor/dto/content-state';
 import { VegaRichTextContentStateController } from './slimmers/controllers/vega-rich-text-content-state-controller';
 import { VegaRTEExtension } from '../vega-rich-text-editor/extensions/extension.abstract';
 import { RTEExtensionStylesController } from './slimmers/controllers/vega-rich-text-content-extensions-styles-controller';
+import { DarkModeStateControllerSlimmer } from '../../helpers/slimmers/dark-mode-state-controller-slimmer';
 /**
  * @vegaVersion 2.34.0
  */
@@ -14,6 +15,7 @@ export declare class VegaRichTextContent {
   protected readonly vegaRichTextContentRenderer: VegaRichTextContentRenderer;
   protected readonly vegaRichTextContentStateController: VegaRichTextContentStateController;
   protected readonly vegaRichTextContentExtensionsStylesController: RTEExtensionStylesController;
+  protected readonly darkModeStateControllerSlimmer: DarkModeStateControllerSlimmer;
   host: HTMLVegaRichTextContentElement;
   /**
    * Specifies a placeholder string that displays as a
@@ -35,6 +37,7 @@ export declare class VegaRichTextContent {
    * Holds the custom styles generated by extensions.
    */
   extensionStyles: string;
+  isInDarkMode: boolean;
   /**
    * Specifies the text or formatted information displayed by the rich text content, which can be either VegaRTEContent or VegaRTEContentBlock.
    * It is recommended to use the VegaRTEContent type.

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

@@ -58,6 +58,13 @@ export declare abstract class ActionHandleStrategy<T extends ModifyContentAction
    * @returns {boolean} - Whether the caret is at the end of the block.
    */
   protected isCaretPositionAtBlockEnd(block: RTEBlock, node: RTENode, offset: number): boolean;
+  /**
+   * Get the registered DOM element by the RTE entity.
+   *
+   * @param {RTEBlock | RTENode} instance - The RTE block or node instance.
+   * @returns {Nullable<HTMLElement>} The registered DOM element.
+   */
+  protected getDOMByEntity(instance: RTEBlock | RTENode): Nullable<HTMLElement>;
   /**
    * Checks if the caret position is at the end of a specified RTETextNode.
    *

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

@@ -1,6 +1,3 @@
-import { NodeAnnotationTypeEnum } from './node-annotation.abstract';
-import { BlockAnnotationTypeEnum } from './block-annotation.abstract';
-import { CommonAnnotationTypeEnum } from './common-annotation.abstract';
 export declare enum InternalAnnotationTypeEnum {
   SELECTION_RANGE = "SELECTION_RANGE",
   CLEAR_FORMATTING = "CLEAR_FORMATTING",
@@ -9,6 +6,6 @@ export declare enum InternalAnnotationTypeEnum {
 /**
  * Abstract class for all annotations
  */
-export declare abstract class Annotation {
-  abstract readonly type: BlockAnnotationTypeEnum | NodeAnnotationTypeEnum | InternalAnnotationTypeEnum | CommonAnnotationTypeEnum;
+export declare abstract class Annotation<T = string> {
+  abstract readonly type: T;
 }

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

@@ -11,8 +11,8 @@ export declare enum BlockAnnotationTypeEnum {
 /**
  * BlockAnnotation is an abstract class that represents a block annotation.
  */
-export declare abstract class BlockAnnotation extends Annotation {
-  abstract readonly type: BlockAnnotationTypeEnum;
+export declare abstract class BlockAnnotation<T = BlockAnnotationTypeEnum> extends Annotation<T> {
+  abstract readonly type: T;
   /**
    * Generate the style for the annotation.
    *
@@ -33,5 +33,5 @@ export declare abstract class BlockAnnotation extends Annotation {
    * @returns {Nullable<Record<string, unknown>>} JSON item of the annotation
    */
   abstract toJSON(): Nullable<Record<string, unknown>>;
-  abstract clone(): BlockAnnotation;
+  abstract clone(): BlockAnnotation<T>;
 }

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

@@ -5,7 +5,7 @@ import { CommonAnnotation, CommonAnnotationTypeEnum } from './common-annotation.
  */
 export declare class CustomAttributeAnnotation extends CommonAnnotation {
   readonly type: CommonAnnotationTypeEnum.CUSTOM_ATTRIBUTE;
-  private customAttribute;
+  customAttribute: Record<string, string>;
   private readonly BOOLEAN_ATTRS;
   constructor(customAttribute: Record<string, string>);
   /**

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

@@ -1,16 +1,14 @@
 import { AnnotationStyle, RTEBlockAnnotationMapKey, RTEBlockAnnotationMapValue, RTERenderContext, VegaRTEBlockAnnotations, VegaRTEBlockBase, VegaRTEContentBlock, VegaRTETransformOptions } from '../../interface';
-import { BlockAnnotation, BlockAnnotationTypeEnum } from '../annotations/block-annotation.abstract';
 import { AnnotationAction } from '../actions/annotation-action.abstract';
 import { Nullable } from '../../../../types/general';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 import type { VegaRTEContent } from '../content-state';
-import { InternalAnnotationTypeEnum } from '../annotations/annotation.abstract';
-import { LinkGroupAnnotation } from '../annotations/link-group-annotation';
+import { Annotation } from '../annotations/annotation.abstract';
 import type { RTENode } from '../nodes/node.abstract';
 import type { RTEListItemBlock } from './list-item-block';
 import { CustomAttributeAnnotation } from '../annotations/custom-attribute-annotation';
 import { ClassType } from '../../../../types/class.type';
-export declare type BlockAnnotations = Map<RTEBlockAnnotationMapKey, RTEBlockAnnotationMapValue>;
+export declare type BlockAnnotations = Map<string, Annotation>;
 export declare type BlockAnnotationsEntity = [RTEBlockAnnotationMapKey, RTEBlockAnnotationMapValue];
 export declare type RTEBlockParentType = VegaRTEContent | RTEBlock;
 export declare type RTEBlockChildrenType = RTEBlock | RTENode;
@@ -76,16 +74,22 @@ export declare abstract class RTEBlock<P = RTEBlockParentType, C = RTEBlockChild
    * Get annotation by type
    *
    * @typedef T generic type
-   * @param {keyof typeof BlockAnnotationTypeEnum} type - Annotation type
+   * @param {string} type - Annotation type
    * @returns {Nullable<T>} - Annotation
    */
-  getAnnotationByType<T extends BlockAnnotation | LinkGroupAnnotation>(type: keyof typeof BlockAnnotationTypeEnum | InternalAnnotationTypeEnum.LINK_GROUP): Nullable<T>;
+  getAnnotationByType<T extends Annotation>(type: string): Nullable<T>;
   /**
    * Apply action to block
    *
    * @param {AnnotationAction} action - Annotation action
    */
   apply(action: AnnotationAction | ModifyContentAction): void;
+  /**
+   * Get the first node of the block
+   *
+   * @returns {Nullable<RTENode>} The first RTENode or null if no children exist.
+   */
+  getFirstNode(): Nullable<RTENode>;
   /**
    * Check if the block is a list item block
    *

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

@@ -0,0 +1,28 @@
+import { RTEFilterStylesStrategy } from './filter-styles-strategy.abstract';
+/**
+ * Registry for managing filter styles strategies keyed by DTO class name.
+ *
+ * Provides common `register` / `getStrategies` primitives that both output-
+ * filtering strategies (DTO → HTML) and annotation-parsing strategies
+ * (HTML → DTO) build upon.
+ *
+ * TODO: Currently, the filter styles strategies are applied for all rich text editors. We need to apply the strategies with a specific rich text editor instance when we have multiple rich text editors in the future.
+ */
+export declare class RTEFilterStylesStrategyRegistry {
+  protected static readonly registry: Map<string, Set<RTEFilterStylesStrategy>>;
+  /**
+   * Registers a filter styles strategy for a specific DTO class name.
+   * Duplicate strategy instances are ignored.
+   *
+   * @param {string} dtoClassName - The DTO class name (e.g. `RTEListBlock.name`).
+   * @param {RTEFilterStylesStrategy} strategy - The strategy instance to register.
+   */
+  static register(dtoClassName: string, strategy: RTEFilterStylesStrategy): void;
+  /**
+   * Retrieves all strategies registered for a given DTO class name.
+   *
+   * @param {string} dtoClassName - The DTO class name to look up.
+   * @returns {RTEFilterStylesStrategy[]} Registered strategies (empty array if none).
+   */
+  static getStrategies(dtoClassName: string): RTEFilterStylesStrategy[];
+}

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

@@ -0,0 +1,25 @@
+import { Nullable } from '../../../../types/general';
+export declare type RTEFilterStyles = Record<string, string>;
+/**
+ * Abstract strategy class for filtering default styles in the rich text editor.
+ * Concrete strategies define which styles to strip via `stylesToBeFiltered`.
+ *
+ * This base is shared by two kinds of concrete strategies:
+ *   1. Block/node output strategies – filter inline styles when converting DTO → HTML.
+ *   2. Annotation parsing strategies – strip redundant defaults when converting HTML → DTO.
+ */
+export declare abstract class RTEFilterStylesStrategy {
+  /**
+   * The styles that the strategy is responsible for filtering.
+   * Must be defined in each concrete implementation.
+   */
+  protected abstract stylesToBeFiltered: RTEFilterStyles;
+  /**
+   * Removes configured default style properties from the target styles object.
+   * Only properties whose value matches the configured default exactly are deleted.
+   *
+   * @param {Nullable<RTEFilterStyles>} styles - The styles object to mutate.
+   * @returns {boolean} `true` if at least one style was extracted.
+   */
+  protected extractAndDeleteMatchedStyles(styles: Nullable<RTEFilterStyles>): boolean;
+}

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

@@ -1,9 +1,7 @@
 import { RTENodeRenderer } from './node-renderer.abstract';
 import { RTETextNode } from '../../nodes/text-node';
-import { Nullable } from '../../../../../types/general';
 declare class RTETextNodeRenderer extends RTENodeRenderer {
   render(node: RTETextNode): HTMLElement;
-  protected registerRef(ref: Nullable<HTMLElement>, node: RTETextNode): void;
   private renderWithWrapper;
   private renderText;
 }

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

@@ -10,6 +10,8 @@ import { ActionHandleStrategy } from '../dto/action-handle-strategies/action-han
 import { ModifyContentAction } from '../dto/actions/modify-content-action.abstract';
 import type { VegaRTEContent } from '../dto/content-state';
 import { ActionHandlerInterceptor } from '../dto/action-handle-strategies/action-handle-interceptor.abstract';
+import { AnnotationGeneratorStrategyAbstract } from '../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/annotation-generator-strategy.abstract';
+import { AnnotationAction } from '../dto/actions/annotation-action.abstract';
 /**
  * Abstract class for Vega Rich Text Editor extensions.
  */
@@ -24,9 +26,9 @@ export declare abstract class VegaRTEExtension {
    *
    * @param {string} nodeOrBlockClassName - The name of the node or block class.
    * @param {string} actionType - The type of the action.
-   * @param {ActionHandleStrategy<ModifyContentAction, RTENode | RTEBlock | VegaRTEContent>} strategy - The strategy to register.
+   * @param {ActionHandleStrategy<ModifyContentAction | AnnotationAction, RTENode | RTEBlock | VegaRTEContent>} strategy - The strategy to register.
    */
-  static registerActionHandleStrategy(nodeOrBlockClassName: string, actionType: string, strategy: ActionHandleStrategy<ModifyContentAction, RTENode | RTEBlock | VegaRTEContent>): void;
+  static registerActionHandleStrategy(nodeOrBlockClassName: string, actionType: string, strategy: ActionHandleStrategy<ModifyContentAction | AnnotationAction, RTENode | RTEBlock | VegaRTEContent>): void;
   /**
    * Registers an action handler interceptor for a specific node or block class.
    *
@@ -41,6 +43,11 @@ export declare abstract class VegaRTEExtension {
    * @param {RTEExtensionContext} context - The context of the RTE extension.
    */
   initialExtension(context: RTEExtensionContext): void;
+  /**
+   * Callback method invoked when the extension is destroyed.
+   * Override this method to perform any necessary cleanup.
+   */
+  destroyExtension(): void;
   /**
    * Collect custom styles for the extension renderers.
    * If custom nodes have special styles, override this method to provide the styles.
@@ -112,4 +119,10 @@ export declare abstract class VegaRTEExtension {
    * @returns {ElementToDTOStrategy[]} - The registered element to node DTO class strategies.
    */
   protected getElementToNodeDTOClassStrategies(): ElementToDTOStrategy[];
+  /**
+   * Register a custom annotation handler for HTML to DTO conversion.
+   *
+   * @param {AnnotationGeneratorStrategyAbstract} handler - The annotation handler to register.
+   */
+  protected registerAnnotationHandler(handler: AnnotationGeneratorStrategyAbstract): void;
 }

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-interceptors/prevent-cell-children-remove-interceptor.d.ts

@@ -0,0 +1,25 @@
+import { ActionHandlerExecution, ActionHandlerInterceptor } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
+import { RemoveChildrenAction } from '../../../dto/actions/remove-child-action';
+import type { RTETableCellBlock } from '../dto/table-cell-block';
+import type { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
+/**
+ * Interceptor to prevent removal of all children from a cell, ensuring at least one child remains.
+ */
+export declare class PreventCellChildrenRemoveInterceptor extends ActionHandlerInterceptor<RemoveChildrenAction, RTETableCellBlock | RTETableHeadCellBlock> {
+  /**
+   * Prevent removal if the target cell would be left empty after the action.
+   *
+   * @param {RemoveChildrenAction} action - the action to be intercepted
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} target - the target cell block
+   * @returns {boolean} - true if the removal should be intercepted, false otherwise
+   */
+  canIntercept(action: RemoveChildrenAction, target: RTETableCellBlock | RTETableHeadCellBlock): boolean;
+  /**
+   * Add a new empty text node to the cell to prevent it from removal.
+   *
+   * @param {ActionHandlerExecution} _execution - the original execution function
+   * @param {RemoveChildrenAction} action - the action to be intercepted
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} target - the target cell block
+   */
+  intercept(_execution: ActionHandlerExecution, action: RemoveChildrenAction, target: RTETableCellBlock | RTETableHeadCellBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-interceptors/prevent-cell-content-delete-interceptor.d.ts

@@ -0,0 +1,20 @@
+import { ActionHandlerInterceptor } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
+import { DeleteBlockContentAction } from '../../../dto/actions/delete-block-content-action';
+import type { RTETextBlock } from '../../../dto/blocks/text-block';
+/**
+ * Interceptor to prevent deletion of a table cell if it is the cell with empty content.
+ */
+export declare class PreventCellContentDeleteInterceptor extends ActionHandlerInterceptor<DeleteBlockContentAction, RTETextBlock> {
+  /**
+   * Prevent deletion if the target block is the only child of a table cell and is empty.
+   *
+   * @param {DeleteBlockContentAction} action - the action to be intercepted
+   * @param {RTETextBlock} target - the target block
+   * @returns {boolean} - true if the deletion should be intercepted, false otherwise
+   */
+  canIntercept(action: DeleteBlockContentAction, target: RTETextBlock): boolean;
+  /**
+   * @inheritDoc
+   */
+  intercept(): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-interceptors/prevent-row-insert-interceptor.d.ts

@@ -0,0 +1,19 @@
+import type { InsertChildrenBeforeAction } from '../../../dto/actions/insert-children-before-block';
+import type { RTETableRowBlock } from '../dto/table-row-block';
+import { ActionHandlerInterceptor } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
+/**
+ * Interceptor to prevent insertion of non-cell blocks into a table row.
+ */
+export declare class PreventRowInsertInterceptor extends ActionHandlerInterceptor<InsertChildrenBeforeAction, RTETableRowBlock> {
+  /**
+   * Prevent insertion if any of the children to be inserted is not a table cell block.
+   *
+   * @param {InsertChildrenBeforeAction} action - the action to be intercepted
+   * @returns {boolean} - true if the insertion should be intercepted, false otherwise
+   */
+  canIntercept(action: InsertChildrenBeforeAction): boolean;
+  /**
+   * @inheritDoc
+   */
+  intercept(): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-interceptors/prevent-table-insert-paragraph-interceptor.d.ts

@@ -0,0 +1,31 @@
+import { ActionHandlerExecution, ActionHandlerInterceptor } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
+import type { InsertNewParagraphAction } from '../../../dto/actions/insert-new-paragraph-action';
+import type { RTETableBlock } from '../dto/table-block';
+/**
+ * Interceptor to insert a paragraph before or after a table block.
+ */
+export declare class PreventTableInsertParagraphInterceptor extends ActionHandlerInterceptor<InsertNewParagraphAction, RTETableBlock> {
+  /**
+   * Intercept insert paragraph action when table block has a parent.
+   *
+   * @param {InsertNewParagraphAction} _action - the action to be intercepted
+   * @param {RTETableBlock} target - the target table block
+   * @returns {boolean} - whether the action should be intercepted
+   */
+  canIntercept(_action: InsertNewParagraphAction, target: RTETableBlock): boolean;
+  /**
+   * Insert a new paragraph block before or after the current table block based on caret offset.
+   *
+   * @param {ActionHandlerExecution} _execution - the original execution function
+   * @param {InsertNewParagraphAction} action - the action containing insert metadata
+   * @param {RTETableBlock} target - the target table block
+   */
+  intercept(_execution: ActionHandlerExecution, action: InsertNewParagraphAction, target: RTETableBlock): void;
+  /**
+   * Create a new empty paragraph block.
+   *
+   * @param {string} text - paragraph text
+   * @returns {Nullable<RTETextBlock>} - paragraph block when paragraph dto class is available
+   */
+  private createNewParagraph;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/create-segment-table-cell-strategy.d.ts

@@ -0,0 +1,20 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { CreateSegmentTableCellAction } from '../actions/create-segment-table-cell-action';
+import { RTETableRowBlock } from '../dto/table-row-block';
+/**
+ * Strategy to create a split segment table cell.
+ */
+export declare class CreateSegmentTableCellStrategy extends ActionHandleStrategy<CreateSegmentTableCellAction, RTETableRowBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: CreateSegmentTableCellAction, row: RTETableRowBlock): void;
+  /**
+   * Convert a cell to the requested table cell type.
+   *
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} cell - Cell to convert.
+   * @param {string} targetCellType - Requested cell type.
+   * @returns {RTETableCellBlock | RTETableHeadCellBlock} Converted cell.
+   */
+  private convertCellType;
+}