@heartlandone/vega 2.78.0 → 2.79.0

package/dist/types/components/vega-rich-text-editor/extensions/table/element-to-dto-strategies/table-to-table-block-strategy.d.ts

@@ -0,0 +1,26 @@
+import { Nullable } from '../../../../../types/general';
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { VegaRTECustomNode, VegaRTETransformOptions } from '../../../interface';
+import { ElementToDTOStrategy } from '../../../slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
+import { RTETableBlock } from '../dto/table-block';
+/**
+ * Strategy to convert a native HTML table element into an RTETableBlock DTO.
+ */
+export declare class TableToTableBlockStrategy extends ElementToDTOStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions): Nullable<RTEBlock | VegaRTECustomNode>;
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks(currentBlock: RTETableBlock, childBlocks: RTEBlock[]): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/element-to-dto-strategies/tbody-to-table-body-block-strategy.d.ts

@@ -0,0 +1,26 @@
+import { Nullable } from '../../../../../types/general';
+import { BlockToRTEBlockStrategyAbstract } from '../../../slimmers/controllers/helper/element-to-dto-strategy/block-to-rte-block-strategy.abstract';
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTETableBodyBlock } from '../dto/table-body-block';
+import { VegaRTETransformOptions } from '../../../interface';
+/**
+ * Strategy to convert a native HTML tbody element into an RTETableBodyBlock DTO.
+ */
+export declare class TbodyToTableBodyBlockStrategy extends BlockToRTEBlockStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions): Nullable<RTEBlock>;
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks(currentBlock: RTETableBodyBlock, childBlocks: RTEBlock[]): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/element-to-dto-strategies/td-to-table-cell-block-strategy.d.ts

@@ -0,0 +1,35 @@
+import { Nullable } from '../../../../../types/general';
+import { BlockToRTEBlockStrategyAbstract } from '../../../slimmers/controllers/helper/element-to-dto-strategy/block-to-rte-block-strategy.abstract';
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
+import { VegaRTETransformOptions } from '../../../interface';
+/**
+ * Strategy to convert native HTML td/th element into table cell DTOs.
+ */
+export declare class TdToTableCellBlockStrategy extends BlockToRTEBlockStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions): Nullable<RTEBlock>;
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks(currentBlock: RTETableCellBlock | RTETableHeadCellBlock, childBlocks: RTEBlock[]): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+  /**
+   * Generates annotations for a table head cell element.
+   *
+   * @param {HTMLElement} element The HTML element representing the table head.
+   * @param {VegaRTETransformOptions} options Optional transformation options.
+   * @returns {VegaRTETableHeadCellBlock['annotations']} The annotations for the table head element.
+   */
+  private getTableHeadCellAnnotations;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/element-to-dto-strategies/thead-to-table-head-block-strategy.d.ts

@@ -0,0 +1,26 @@
+import { Nullable } from '../../../../../types/general';
+import { BlockToRTEBlockStrategyAbstract } from '../../../slimmers/controllers/helper/element-to-dto-strategy/block-to-rte-block-strategy.abstract';
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTETableHeadBlock } from '../dto/table-head-block';
+import { VegaRTETransformOptions } from '../../../interface';
+/**
+ * Strategy to convert a native HTML thead element into an RTETableHeadBlock DTO.
+ */
+export declare class TheadToTableHeadBlockStrategy extends BlockToRTEBlockStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions): Nullable<RTEBlock>;
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks(currentBlock: RTETableHeadBlock, childBlocks: RTEBlock[]): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/element-to-dto-strategies/tr-to-table-row-block-strategy.d.ts

@@ -0,0 +1,26 @@
+import { Nullable } from '../../../../../types/general';
+import { BlockToRTEBlockStrategyAbstract } from '../../../slimmers/controllers/helper/element-to-dto-strategy/block-to-rte-block-strategy.abstract';
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTETableRowBlock } from '../dto/table-row-block';
+import { VegaRTETransformOptions } from '../../../interface';
+/**
+ * Strategy to convert a native HTML tr element into an RTETableRowBlock DTO.
+ */
+export declare class TrToTableRowBlockStrategy extends BlockToRTEBlockStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions): Nullable<RTEBlock>;
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks(currentBlock: RTETableRowBlock, childBlocks: RTEBlock[]): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-body-renderer.d.ts

@@ -0,0 +1,12 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTETableBodyBlock } from '../dto/table-body-block';
+/**
+ * Renders a table body block in the rich text editor.
+ */
+export declare class RTETableBodyRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableBodyBlock): VegaRTERenderResult;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-caption-renderer.d.ts

@@ -0,0 +1,13 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTETableCaptionBlock } from '../dto/table-caption-block';
+export declare const TABLE_CAPTION_PLACEHOLDER_TEXT: string;
+/**
+ * Renderer for the optional table caption node.
+ */
+export declare class RTETableCaptionRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableCaptionBlock): VegaRTERenderResult;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-cell-renderer.d.ts

@@ -0,0 +1,30 @@
+import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+/**
+ * Renders a table cell block in the rich text editor.
+ */
+export declare class RTETableCellRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableCellBlock, rteContext: RTERenderContext): VegaRTERenderResult;
+  /**
+   * Renders the table cell based on its type (td or th).
+   *
+   * @param {VegaRTECreateElementFunction} h - The create element function.
+   * @param {RTETableCellBlock} renderData - The table cell block to render.
+   * @param {RTERenderContext} rteContext - The rte editor context.
+   * @param {'td' | 'th'} elementType - The type of table cell element ('td' or 'th').
+   * @returns {VegaRTERenderResult} - The rendered table cell element.
+   */
+  protected renderByCellType(h: VegaRTECreateElementFunction, renderData: RTETableCellBlock, rteContext: RTERenderContext, elementType: 'td' | 'th'): VegaRTERenderResult;
+  /**
+   * Returns the mouse event listeners for selection handling.
+   *
+   * @param {RTETableCellBlock} renderData - The table cell block to render.
+   * @param {RTERenderContext} rteContext - The rte editor context.
+   * @returns {RTETableSelectionListenersType} - The mouse event listeners.
+   */
+  private onSelectionListeners;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-dynamic-popover-renderer.d.ts

@@ -0,0 +1,81 @@
+import { RTERenderContext, VegaRTEColorSchema, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { Nullable } from '../../../../../types/general';
+import { RTETableBlock } from '../dto/table-block';
+import { TablePopoverBaseRenderer } from './table-popover-base-renderer';
+/**
+ * Renderer for a generic, dynamically positioned popover used within table-related extensions.
+ *
+ * - The popover target is based on the current cursor/selection position.
+ * - The popover content is rendered dynamic content.
+ */
+export declare class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
+  private popoverRef;
+  private getTableRef;
+  private selectionAnchorRef;
+  private tableColorSchema;
+  private currentTableBlock;
+  private currentFocusNode;
+  private tablePropertiesFormRef;
+  private cellPropertiesFormRef;
+  private popoverCloseType;
+  private tablePropertiesHandlerMap;
+  private cellPropertiesHandlerMap;
+  constructor(colors: VegaRTEColorSchema[], renderContext: RTERenderContext);
+  /**
+   * removes the multi-cell selection anchor element from the DOM, if present,
+   * and clears the internal reference.
+   */
+  destroy(): void;
+  /**
+   * Shows the popover. Before showing, it will refresh the target so
+   * that the popover is positioned relative to the latest cursor position.
+   *
+   * @param {string} type - The table setting type determining which
+   *  content variant to display (for example, table properties or cell properties).
+   */
+  show(type: string): Promise<void>;
+  /**
+   * hide the popover.
+   */
+  hide(): Promise<void>;
+  /**
+   * Renders a vega-popover whose target and content are provided dynamically by callers.
+   *
+   * @param {VegaRTECreateElementFunction} h - The create element function.
+   * @param {() => HTMLElement} getTableRef - Current table DOM reference
+   * @param {RTETableBlock} renderData - Current table block being rendered.
+   * @returns {VegaRTERenderResult} The rendered popover host.
+   */
+  render(h: VegaRTECreateElementFunction, getTableRef: () => Nullable<HTMLElement>, renderData: RTETableBlock): VegaRTERenderResult;
+  /**
+   * Updates the visibility of the pre-rendered content blocks based on type.
+   *
+   * @param {string} type - The table setting type determining which content variant should be visible.
+   */
+  private updateContent;
+  /**
+   * Updates the table properties based on the emitted event.
+   *
+   * @param {CustomEvent} e - The custom event containing the update details.
+   */
+  private handleTablePropertiesUpdate;
+  /**
+   * Stores the current focus node before properties update action.
+   */
+  private storeCurrentFocusNode;
+  /**
+   * Create and position an invisible anchor element whose position and size are identical to the geometry of the current multi-cell selection.
+   * This anchor element will then be used as the target of the popup, so that the popup appears near the entire selection area.
+   *
+   * @param {RTETableCellBlock[]} cells - The currently selected table cells.
+   * @param {Nullable<HTMLElement>} tableRef - The container table element.
+   * @returns {Nullable<HTMLElement>} The positioned anchor element.
+   */
+  private getOrCreateSelectionAnchor;
+  /**
+   * Updates the cell properties based on the emitted event.
+   *
+   * @param {CustomEvent} e - The custom event containing the update details.
+   */
+  private handleCellPropertiesUpdate;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-head-cell-renderer.d.ts

@@ -0,0 +1,12 @@
+import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { RTETableCellRenderer } from './table-cell-renderer';
+import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
+/**
+ * Renders a head cell block in the rich text editor.
+ */
+export declare class RTETableHeadCellRenderer extends RTETableCellRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableHeadCellBlock, rteContext: RTERenderContext): VegaRTERenderResult;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-head-renderer.d.ts

@@ -0,0 +1,12 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTETableBlock } from '../dto/table-block';
+/**
+ * Renders a logic control block in the rich text editor.
+ */
+export declare class RTETableHeadRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableBlock): VegaRTERenderResult;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-popover-base-renderer.d.ts

@@ -0,0 +1,16 @@
+import { Nullable } from '../../../../../types/general';
+import { RTERenderContext, VegaRTEToolbarRenderContext } from '../../../interface';
+import { RTETableExtensionContext } from '../table-extension';
+/**
+ * Base renderer for table-related popovers, providing common functionalities such as accessing the table extension context.
+ */
+export declare class TablePopoverBaseRenderer {
+  protected renderContext: Nullable<RTERenderContext | VegaRTEToolbarRenderContext>;
+  constructor(renderContext: RTERenderContext | VegaRTEToolbarRenderContext);
+  /**
+   * Retrieves the table extension context associated with the current render context.
+   *
+   * @returns {Nullable<RTETableExtensionContext>} The table extension context if available, otherwise null.
+   */
+  protected getTableExtensionContext(): Nullable<RTETableExtensionContext>;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-renderer.d.ts

@@ -0,0 +1,38 @@
+import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTETableBlock } from '../dto/table-block';
+/**
+ * Renderer for the RTETableBlock.
+ */
+export declare class RTETableBlockRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableBlock, rteContext: RTERenderContext): VegaRTERenderResult;
+  /**
+   * @inheritDoc
+   */
+  injectRTEScopeStyles(): string;
+  /**
+   * Renders the table element.
+   *
+   * @param {VegaRTECreateElementFunction} h - The create element function.
+   * @param {RTETableBlock} renderData - The table block to render.
+   * @param {(ref: HTMLElement) => HTMLElement} setTableRef - Set table ref to tableRef
+   * @returns {VegaRTERenderResult} - The rendered table element.
+   */
+  private renderTable;
+  /**
+   * Handles the removal of the table block.
+   *
+   * @param {RTETableBlock} renderData - The table block to remove.
+   * @param {HTMLElement} tableRef - The element that can triggered the table popover open.
+   */
+  private handleTableRemove;
+  /**
+   * Notifies and clears the multi-cell selection anchor associated with the given table reference.
+   *
+   * @param {HTMLElement} tableRef - The table trigger element used to locate the rich text content container.
+   */
+  private destroySelectionAnchor;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-row-renderer.d.ts

@@ -0,0 +1,12 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTETableRowBlock } from '../dto/table-row-block';
+/**
+ * Renders a logic control block in the rich text editor.
+ */
+export declare class RTETableRowBlockRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableRowBlock): VegaRTERenderResult;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-setting-popover-renderer.d.ts

@@ -0,0 +1,59 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { RTETableBlock } from '../dto/table-block';
+import { TableDynamicPopoverRenderer } from './table-dynamic-popover-renderer';
+import { TablePopoverBaseRenderer } from './table-popover-base-renderer';
+/**
+ * Centralizes the popover rendering and interaction logic for table settings.
+ */
+export declare class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
+  private popoverRef;
+  private tableSettingRef;
+  private tableData;
+  private tableDynamicPopover;
+  private popoverShow;
+  private settingHandlers;
+  /**
+   * Show table setting popover when table is clicked.
+   * Only the popover belonging to the nearest table will be shown,
+   * which avoids outer tables showing their popover when an inner (nested) table is clicked.
+   *
+   * @param {MouseEvent} event - The MouseEvent that triggered the table action
+   * @param {HTMLElement} trigger - The element that can triggered the popover open.
+   */
+  handleTableClick: (event: MouseEvent, trigger: HTMLElement) => void;
+  /**
+   * Sync the selected cells from the table selection to the table setting component.
+   */
+  syncSelectedCells: () => void;
+  /**
+   * Render the popover host and inject the table-setting component with refs wired up.
+   *
+   * @param {VegaRTECreateElementFunction} h - The create element function.
+   * @param {RTETableBlock} renderData - The table block to render.
+   * @param {() => HTMLElement} getTableRef - Current table DOM reference
+   * @param {TableDynamicPopoverRenderer} tableDynamicPopover - Renderer used to show
+   *  the secondary table popover (for example, table-properties-specific settings).
+   * @returns {VegaRTERenderResult} The rendered popover structure.
+   */
+  render(h: VegaRTECreateElementFunction, renderData: RTETableBlock, getTableRef: () => HTMLElement, tableDynamicPopover: TableDynamicPopoverRenderer): VegaRTERenderResult;
+  /**
+   * Updates the table setting component caption state to match the given table data.
+   */
+  private updateTableSettingCaption;
+  /**
+   * Receive setting menu click events.
+   *
+   * @param {CustomEvent<Array<string>>} event - The custom event emitted from the setting menu.
+   */
+  private handleSettingMenuClick;
+  /**
+   * Handles the popover show event to sync the selected table cells to the table setting component.
+   */
+  private handleTableSettingPopoverShow;
+  /**
+   * Collects and returns the currently selected table cells.
+   *
+   * @returns {RTETableCellBlock[]} The array of currently selected table cell blocks.
+   */
+  private getTableSelectedCells;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-toolbar-popover-renderer.d.ts

@@ -0,0 +1,59 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { TablePopoverBaseRenderer } from './table-popover-base-renderer';
+/**
+ * Table toolbar popover renderer class. Render the popover content for the table toolbar button, which includes the table size picker grid.
+ */
+export declare class RTETableToolbarPopoverRenderer extends TablePopoverBaseRenderer {
+  private tablePickerPopoverRef;
+  private tablePickerGridRef;
+  private hoveredRows;
+  private hoveredCols;
+  private selectedHintRef;
+  /**
+   * Renders the table toolbar popover.
+   *
+   * @param {VegaRTECreateElementFunction} h - Create element function.
+   * @param {VegaRTERenderResult} children - Child elements to be rendered inside the popover.
+   * @returns {VegaRTERenderResult} Render result for the table toolbar popover.
+   */
+  render(h: VegaRTECreateElementFunction, children: VegaRTERenderResult): VegaRTERenderResult;
+  /**
+   * Generates the table size picker grid.
+   *
+   * @param {VegaRTECreateElementFunction} h - Create element function.
+   * @returns {VegaRTERenderResult} - The render result for the table size picker.
+   */
+  private generateTableSizeGrid;
+  /**
+   * Generates the styles for the table size picker.
+   *
+   * @param {VegaRTECreateElementFunction} h - Create element function.
+   * @returns {VegaRTERenderResult} - The render result for the styles.
+   */
+  private generatePickerStyles;
+  /**
+   * Creates a table block with the specified number of rows and columns.
+   *
+   * @param {number} row - The number of rows for the table.
+   * @param {number} column - The number of columns for the table.
+   */
+  private createTable;
+  /**
+   * Handles the click event on a picker cell.
+   *
+   * @param {number} r - The number of rows selected.
+   * @param {number} c - The number of columns selected.
+   */
+  private handlePickerClick;
+  /**
+   * Handles the hover event on a picker cell.
+   *
+   * @param {number} r - The number of rows being hovered over.
+   * @param {number} c - The number of columns being hovered over.
+   */
+  private handlePickerCellHover;
+  /**
+   * Resets the table picker to its initial state.
+   */
+  private resetPicker;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/setting-event-handlers/caption-operation.d.ts

@@ -0,0 +1,36 @@
+import { Nullable } from '../../../../../types/general';
+import { RTEExtensionContext } from '../../../interface';
+import { RTETableBlock } from '../dto/table-block';
+import { SettingEventHandler } from './setting-event-handler.abstract';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+/**
+ * Event handler for row operations in a table.
+ */
+export declare class CaptionOperationEventHandler extends SettingEventHandler {
+  /**
+   * @inheritDoc
+   */
+  canHandle(action: Array<string>): boolean;
+  /**
+   * Toggle caption state for the target table block when the caption menu item is clicked.
+   *
+   * @param {Array<string>} action - Table setting payload, e.g. ['CAPTION', 'rte-table-caption'].
+   * @param {RTEExtensionContext} _extensionContext - Current editor extension context (unused here).
+   * @param {RTETableBlock} tableBlock - Table block that owns the caption.
+   */
+  execute(action: Array<string>, _extensionContext: RTEExtensionContext, tableBlock: RTETableBlock): void;
+  /**
+   * Applies a cursor update action so the editor focuses on the resolved node.
+   *
+   * @param {RTETableBlock} block - Table block currently being toggled.
+   * @param {Nullable<RTENode>} focusNode - Target node that should receive the caret.
+   */
+  protected syncCursorPosition(block: RTETableBlock, focusNode: Nullable<RTENode>): void;
+  /**
+   * Build a fresh caption block with a default paragraph + placeholder text.
+   *
+   * @param {string} id - table-caption id
+   * @returns {RTETableCaptionBlock} Newly created caption DTO ready for rendering.
+   */
+  private createCaptionBlock;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/setting-event-handlers/cell-properties-cancel-event-handler.d.ts

@@ -0,0 +1,17 @@
+import { RTETablePropertiesType } from '../../../interface';
+import { RTETableExtensionContext } from '../table-extension';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { CellPropertiesEventHandler } from './cell-properties';
+/**
+ * Cancel Event handler for the cell properties.
+ */
+export declare class CellPropertiesCancelEventHandler extends CellPropertiesEventHandler {
+  /**
+   * Cancel cell properties changes
+   *
+   * @param {RTETableExtensionContext} extensionContext - The table extension context.
+   * @param {Record<string, RTETablePropertiesType>} data - The origin of the properties.
+   * @param {RTENode} focusNode - The focus node.
+   */
+  handle(extensionContext: RTETableExtensionContext, data: Record<string, RTETablePropertiesType>, focusNode?: RTENode): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/setting-event-handlers/cell-properties-change-event-handler.d.ts

@@ -0,0 +1,15 @@
+import { RTETablePropertiesType } from '../../../interface';
+import { RTETableExtensionContext } from '../table-extension';
+import { CellPropertiesEventHandler } from './cell-properties';
+/**
+ * Change Event handler for the cell properties.
+ */
+export declare class CellPropertiesChangeEventHandler extends CellPropertiesEventHandler {
+  /**
+   * Update the cell properties based on the provided data.
+   *
+   * @param {RTETableExtensionContext} extensionContext - The table extension context.
+   * @param {Record<string, RTETablePropertiesType>} data - The origin of the properties.
+   */
+  handle(extensionContext: RTETableExtensionContext, data: Record<string, RTETablePropertiesType>): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/setting-event-handlers/cell-properties-save-event-handler.d.ts

@@ -0,0 +1,17 @@
+import { RTETableExtensionContext } from '../table-extension';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { CellPropertiesEventHandler } from './cell-properties';
+import { RTETablePropertiesType } from '../../../interface';
+/**
+ * Save Event handler for the cell properties.
+ */
+export declare class CellPropertiesSaveEventHandler extends CellPropertiesEventHandler {
+  /**
+   * Commit the cell properties changes
+   *
+   * @param {RTETableExtensionContext} extensionContext - The table extension context.
+   * @param {Record<string, RTETablePropertiesType>} _data - The origin of the properties.
+   * @param {RTENode} focusNode - The focus node.
+   */
+  handle(extensionContext: RTETableExtensionContext, _data: Record<string, RTETablePropertiesType>, focusNode?: RTENode): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/setting-event-handlers/cell-properties.d.ts

@@ -0,0 +1,62 @@
+import { Nullable } from '../../../../../types/general';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { RTETablePropertiesType, TableCellStylePropertiesMap } from '../../../interface';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+import { RTETableExtensionContext } from '../table-extension';
+/**
+ * Event handler for cell properties in a table.
+ */
+export declare abstract class CellPropertiesEventHandler {
+  /**
+   * Get the style collection from the selected table cells.
+   *
+   * @param {RTETableCellBlock[]} selectedCells - The selected table cells to merge styles from
+   * @returns {TableCellStylePropertiesMap} The merged styles object containing only common style properties
+   */
+  static getStyleCollectionFromCell(selectedCells: RTETableCellBlock[]): TableCellStylePropertiesMap;
+  /**
+   * Convert the style collection prop to a form field value by merging styles.
+   *
+   * @param {TableCellStylePropertiesMap} styleMap - The default value prop.
+   * @returns {RTETablePropertiesType} The merged form field value.
+   */
+  static convertStyleMapToFormField(styleMap: TableCellStylePropertiesMap): RTETablePropertiesType;
+  /**
+   * Apply the given properties to the selected cells
+   *
+   * @param {RTETableExtensionContext} extensionContext The extensionContext
+   * @param {Record<string, RTETablePropertiesType>} properties - The properties to apply
+   * @param {boolean} isFlushable - Whether the action is flushable
+   */
+  protected applyProperties(extensionContext: RTETableExtensionContext, properties: Record<string, RTETablePropertiesType>, isFlushable: boolean): void;
+  /**
+   * Update the rich text editor cursor position
+   *
+   * @param {RTETableExtensionContext} extensionContext - The table extension context.
+   * @param {Nullable<RTENode>} focusNode - The node to focus on.
+   */
+  protected updateCursorPosition(extensionContext: RTETableExtensionContext, focusNode: Nullable<RTENode>): void;
+  /**
+   * Convert RTETablePropertiesType to VegaRTETableCellAnnotation
+   *
+   * @param {RTETablePropertiesType} originalStyles - The original style properties
+   * @returns {VegaRTETableCellAnnotation} The converted VegaRTETableCellAnnotation
+   */
+  private convertToVegaTableCellAnnotation;
+  /**
+   * Apply the given annotation to the specified table cell
+   *
+   * @param {RTETableCellBlock} cell - The table cell to apply the annotation to
+   * @param {VegaRTETableCellAnnotation} annotation - The annotation to apply
+   * @param {boolean} isFlushable - Whether the action is flushable
+   */
+  private applyAnnotation;
+  /**
+   * Handle the event
+   *
+   * @param {RTETableExtensionContext} context - The table extension context.
+   * @param { Record<string, RTETablePropertiesType>} data - The table properties data.
+   * @param {RTENode} focusNode - The node to focus on.
+   */
+  abstract handle(context: RTETableExtensionContext, data: Record<string, RTETablePropertiesType>, focusNode?: RTENode): void;
+}