@heartlandone/vega 2.77.1 → 2.79.0

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

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

@@ -0,0 +1,55 @@
+import { RTETableExtensionContext } from '../table-extension';
+import { SettingEventHandler } from './setting-event-handler.abstract';
+export declare enum ColumnOperationType {
+  HEADER_COLUMN = "HEADER_COLUMN",
+  ADD_COLUMN_LEFT = "ADD_COLUMN_LEFT",
+  ADD_COLUMN_RIGHT = "ADD_COLUMN_RIGHT",
+  DELETE_COLUMN = "DELETE_COLUMN",
+  SELECT_COLUMN = "SELECT_COLUMN"
+}
+/**
+ * Event handler for column operations in a table.
+ */
+export declare class ColumnOperationEventHandler extends SettingEventHandler {
+  /**
+   * @inheritDoc
+   */
+  canHandle(action: Array<string>): boolean;
+  /**
+   * @inheritDoc
+   */
+  execute(action: Array<string>, extensionContext: RTETableExtensionContext): void;
+  /**
+   * Adds a new column to the table at the specified position.
+   *
+   * @param {ColumnOperationType} direction - The position to insert the new column (left or right).
+   * @param {RTETableCellBlock[] | RTETableHeadCellBlock[]} selectedCells - The selected table cells.
+   */
+  private handleInsertColumn;
+  /**
+   * Deletes the selected column from the table.
+   *
+   * @param {RTETableCellBlock[] | RTETableHeadCellBlock[]} selectedCells - The selected table cells.
+   */
+  private handleDeleteColumn;
+  /**
+   * Selects the entire column in the table.
+   *
+   * @param {RTETableCellBlock[] | RTETableHeadCellBlock[]} selectedCells - The selected table cells.
+   * @param {RTETableExtensionContext} extensionContext - The table extension context.
+   */
+  private handleSelectColumn;
+  /**
+   * Toggles the header state of the selected column in the table.
+   *
+   * @param {RTETableCellBlock[] | RTETableHeadCellBlock[]} selectedCells - The selected table cells.
+   */
+  private handleToggleHeaderColumn;
+  /**
+   * Apply the specified action on the table containing the selected cell.
+   *
+   * @param {DeleteTableColumnAction | InsertTableColumnAction} action - The action to apply.
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} selectedCell - The selected table cell.
+   */
+  private applyActionOnTable;
+}

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

@@ -0,0 +1,44 @@
+import { RTETableExtensionContext } from '../table-extension';
+import { SettingEventHandler } from './setting-event-handler.abstract';
+export declare enum MergeCellsOperationType {
+  MERGE_CELLS = "MERGE_CELLS",
+  MERGE_CELL_UP = "MERGE_CELL_UP",
+  MERGE_CELL_RIGHT = "MERGE_CELL_RIGHT",
+  MERGE_CELL_DOWN = "MERGE_CELL_DOWN",
+  MERGE_CELL_LEFT = "MERGE_CELL_LEFT"
+}
+/**
+ * Event handler for merge cells operations in a table.
+ */
+export declare class MergeCellsOperationEventHandler extends SettingEventHandler {
+  /**
+   * @inheritDoc
+   */
+  canHandle(action: Array<string>): boolean;
+  /**
+   * @inheritDoc
+   */
+  execute(action: Array<string>, extensionContext: RTETableExtensionContext): void;
+  /**
+   * Get the adjacent cell in the specified direction.
+   *
+   * @param {MergeCellsOperationType} direction - The direction to look for the adjacent cell.
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} cell - The current cell.
+   * @returns {Array<RTETableCellBlock | RTETableHeadCellBlock>} Array containing the cells to merge.
+   */
+  private getDirectionMergeCells;
+  /**
+   * Handle the merge cells operation by creating and applying a MergeCellsAction.
+   *
+   * @param {Array<RTETableCellBlock | RTETableHeadCellBlock>} mergeCells - The cells to merge.
+   * @param {MergeCellsOperationType} direction - The merge cell direction.
+   */
+  private handleMergeCells;
+  /**
+   * Apply the specified action on the table containing the selected cell.
+   *
+   * @param {MergeCellsAction} action - The action to apply.
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} selectedCell - The selected table cell.
+   */
+  private applyActionOnTable;
+}

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

@@ -0,0 +1,69 @@
+import type { RTETableExtensionContext } from '../table-extension';
+import { SettingEventHandler } from './setting-event-handler.abstract';
+export declare enum RowOperationType {
+  HEADER_ROW = "HEADER_ROW",
+  ADD_ROW_ABOVE = "ADD_ROW_ABOVE",
+  ADD_ROW_BELOW = "ADD_ROW_BELOW",
+  DELETE_ROW = "DELETE_ROW",
+  SELECT_ROW = "SELECT_ROW"
+}
+/**
+ * Event handler for row operations in a table.
+ */
+export declare class RowOperationEventHandler extends SettingEventHandler {
+  /**
+   * @inheritDoc
+   */
+  canHandle(action: Array<string>): boolean;
+  /**
+   * @inheritDoc
+   */
+  execute(action: Array<string>, extensionContext: RTETableExtensionContext): void;
+  /**
+   * Adds a new row to the table at the specified position.
+   *
+   * @param {RowOperationType} direction - The position to insert the new row (above or below).
+   * @param {RTETableExtensionContext} extensionContext - The extension context.
+   */
+  private handleInsertRow;
+  /**
+   * Checks if a header row should be inserted based on the selected rows and position.
+   *
+   * @param {RTETableRowBlock} refBlock - The reference table row block.
+   * @param {InsertTableRowDirection} direction - The direction to insert the new row (above or below).
+   * @returns {boolean} True if a header row should be inserted, false otherwise.
+   */
+  private shouldInsertHeaderRow;
+  /**
+   * Deletes the selected row(s) from the table.
+   *
+   * @param {RTETableExtensionContext} extensionContext - The extension context.
+   */
+  private handleDeleteRow;
+  /**
+   * Converts selected rows to header rows or reverts them back to normal rows.
+   *
+   * @param {RTETableExtensionContext} extensionContext - The extension context.
+   */
+  private handleToggleHeader;
+  /**
+   * Selects the focus row(s) in the table.
+   *
+   * @param {RTETableExtensionContext} extensionContext - The extension context.
+   */
+  private handleSelectRow;
+  /**
+   * Get all selected table rows.
+   *
+   * @param {RTETableExtensionContext} extensionContext - The extension context.
+   * @returns {RTETableRowBlock[]} The selected table row blocks.
+   */
+  private getAllSelectedRows;
+  /**
+   * Applies the given action to the table containing the reference block.
+   *
+   * @param {RTEBlock} refBlock - The reference block within the table.
+   * @param {ModifyContentAction} action - The action to apply to the table.
+   */
+  private applyActionToTable;
+}

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

@@ -0,0 +1,48 @@
+import { RTEExtensionContext } from '../../../interface';
+import { RTETableBlock } from '../dto/table-block';
+import { Nullable } from '../../../../../types/general';
+import { VegaRTEContent } from '../../../dto/content-state';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+export declare enum TableSettingType {
+  ROW = "ROW",
+  CAPTION = "CAPTION",
+  COLUMN = "COLUMN",
+  MERGE_CELLS = "MERGE_CELLS",
+  TABLE = "TABLE",
+  CELL = "CELL",
+  SPLIT_CELL = "SPLIT_CELL"
+}
+/**
+ * Abstract class for setting event handlers.
+ */
+export declare abstract class SettingEventHandler {
+  /**
+   * 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;
+  /**
+   * Walks up the parent chain to locate the nearest VegaRTEContent root.
+   *
+   * @param {RTETableBlock} block - Table block used as the starting point.
+   * @returns {Nullable<VegaRTEContent>} Content root containing the table, if found.
+   */
+  protected findRootContent(block: RTETableBlock): Nullable<VegaRTEContent>;
+  /**
+   * Determines if the handler can process the given action.
+   *
+   * @param {Array<string>} action - The action to check.
+   */
+  abstract canHandle(action: Array<string>): boolean;
+  /**
+   * Determines how to handle the given action.
+   *
+   * @param {Array<string>} action - The action to handle.
+   * @param {RTEExtensionContext} extensionContext - The context for the extension.
+   * @param {RTETableBlock} tableBlock - The table dto instance.
+   * @param {unknown} data - The data associated with the action.
+   */
+  abstract execute(action: Array<string>, extensionContext: RTEExtensionContext, tableBlock: RTETableBlock, data?: unknown): void;
+}

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

@@ -0,0 +1,31 @@
+import { RTETableExtensionContext } from '../table-extension';
+import { SettingEventHandler } from './setting-event-handler.abstract';
+export declare enum SplitCellOperationType {
+  SPLIT_CELL_HORIZONTALLY = "SPLIT_CELL_HORIZONTALLY",
+  SPLIT_CELL_VERTICALLY = "SPLIT_CELL_VERTICALLY"
+}
+/**
+ * Event handler for split cell operations in a table.
+ */
+export declare class SplitCellOperationEventHandler extends SettingEventHandler {
+  /**
+   * @inheritDoc
+   */
+  canHandle(action: Array<string>): boolean;
+  /**
+   * @inheritDoc
+   */
+  execute(action: Array<string>, extensionContext: RTETableExtensionContext): void;
+  /**
+   * Splits the selected table cell horizontally (split top/bottom).
+   *
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} selectedCell - The table cell block to split.
+   */
+  private handleSplitCellHorizontally;
+  /**
+   * Splits the selected table cell vertically (split left/right).
+   *
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} selectedCell - The table cell block to split.
+   */
+  private handleSplitCellVertically;
+}

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

@@ -0,0 +1,19 @@
+import { RTETablePropertiesType } from '../../../interface';
+import { RTETableBlock } from '../dto/table-block';
+import { TablePropertiesEventHandler } from './table-properties';
+import { RTETableExtensionContext } from '../table-extension';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+/**
+ * Cancel Event handler for the table properties.
+ */
+export declare class TablePropertiesCancelEventHandler extends TablePropertiesEventHandler {
+  /**
+   * Cancel table properties changes
+   *
+   * @param {RTETableExtensionContext} extensionContext - The table extension context.
+   * @param {RTETableBlock} tableBlock - The table block that owns the properties.
+   * @param {RTETablePropertiesType} data - The origin of the properties.
+   * @param {RTENode} focusNode - The node to focus on.
+   */
+  handle(extensionContext: RTETableExtensionContext, tableBlock: RTETableBlock, data: RTETablePropertiesType, focusNode?: RTENode): void;
+}

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

@@ -0,0 +1,17 @@
+import { RTETablePropertiesType } from '../../../interface';
+import { RTETableBlock } from '../dto/table-block';
+import { TablePropertiesEventHandler } from './table-properties';
+import { RTETableExtensionContext } from '../table-extension';
+/**
+ * Change Event handler for the table properties.
+ */
+export declare class TablePropertiesChangeEventHandler extends TablePropertiesEventHandler {
+  /**
+   * Update the table properties based on the provided data.
+   *
+   * @param {RTETableExtensionContext} _extensionContext - The table extension context.
+   * @param {RTETableBlock} tableBlock - The table block to update
+   * @param {RTETablePropertiesType} [data] - The new table properties data
+   */
+  handle(_extensionContext: RTETableExtensionContext, tableBlock: RTETableBlock, data: RTETablePropertiesType): void;
+}

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

@@ -0,0 +1,17 @@
+import { TablePropertiesEventHandler } from './table-properties';
+import { RTETableExtensionContext } from '../table-extension';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+/**
+ * Save Event handler for the table properties.
+ */
+export declare class TablePropertiesSaveEventHandler extends TablePropertiesEventHandler {
+  /**
+   * Commit the table properties changes
+   *
+   * @param {RTETableExtensionContext} extensionContext - The table extension context.
+   * @param {unknown} _tableBlock - The table block.
+   * @param {unknown} _data - The table properties data.
+   * @param {RTENode} focusNode - The focus node.
+   */
+  handle(extensionContext: RTETableExtensionContext, _tableBlock: unknown, _data: unknown, focusNode?: RTENode): void;
+}

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

@@ -0,0 +1,33 @@
+import { RTETablePropertiesType } from '../../../interface';
+import type { RTETableExtensionContext } from '../table-extension';
+import { RTETableBlock } from '../dto/table-block';
+import { Nullable } from '../../../../../types/general';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+/**
+ * Event handler for row operations in a table.
+ */
+export declare abstract class TablePropertiesEventHandler {
+  /**
+   * Generate form object from table block
+   *
+   * @param {RTETableBlock} tableBlock - The table block
+   * @returns {RTETablePropertiesType} The generated form object
+   */
+  static generateTablePropertiesForm(tableBlock: RTETableBlock): RTETablePropertiesType;
+  /**
+   * 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;
+  /**
+   * Handle the event
+   *
+   * @param {RTETableExtensionContext} context - The table extension context.
+   * @param {RTETableBlock} tableBlock - The table block that owns the properties.
+   * @param {RTETablePropertiesType} data - The table properties data.
+   * @param {RTENode} focusNode - The table properties data.
+   */
+  abstract handle(context: RTETableExtensionContext, tableBlock: RTETableBlock, data: RTETablePropertiesType, focusNode?: RTENode): void;
+}

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

@@ -0,0 +1,36 @@
+import { VegaRTEExtension } from '../extension.abstract';
+import { RTEExtensionContext, VegaRTEColorSchema } from '../../interface';
+import { RTETableSelection } from './table-selection';
+export declare type RTETableExtensionContext = RTEExtensionContext & {
+  /**
+   * Table selection manager
+   */
+  tableSelection: RTETableSelection;
+};
+/**
+ * Function extension class for Vega Rich Text Editor.
+ */
+export declare class VegaRTETableExtension extends VegaRTEExtension {
+  private toolbarButtonRenderer;
+  private tableBlockRenderer;
+  private tableRowBlockRenderer;
+  private tableCellRenderer;
+  private tableHeadCellRenderer;
+  private tableSelection;
+  /**
+   * Instantiate the table extension
+   *
+   * @param {VegaRTEColorSchema[]} colors - The table border color and background color list.
+   */
+  constructor(colors?: VegaRTEColorSchema[]);
+  /**
+   * Initializes the extension with the given context
+   *
+   * @param {RTEExtensionContext} context - extension context
+   */
+  initialExtension(context: RTEExtensionContext): void;
+  /**
+   * @inheritDoc
+   */
+  destroyExtension(): void;
+}

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

@@ -0,0 +1,3 @@
+import { IconPayload } from '../../../../helpers/icon/interface';
+declare const _default: IconPayload;
+export default _default;

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

@@ -0,0 +1,164 @@
+import { RTETableCellBlock } from './dto/table-cell-block';
+import type { RTETableHeadCellBlock } from './dto/table-head-cell-block';
+import { RTEExtensionContext } from '../../interface';
+/**
+ * Table selection helper used for mouse drag selection of cells.
+ */
+export declare class RTETableSelection {
+  /**
+   *  Indicates whether the user is currently performing a drag selection.
+   */
+  private dragging;
+  /**
+   * Anchor cell where the drag selection started.
+   */
+  private anchorCell;
+  /**
+   * Collection of currently selected cells.
+   */
+  private selectedCells;
+  /**
+   * Extension context
+   */
+  private context;
+  private syncRTESelectionWithDebounce;
+  private handleSelectionChangeWithDebounce;
+  /**
+   * Compute all cells inside the rectangle defined by the start and end cells.
+   *
+   * Note: this only performs the calculation and does not modify the internal `selectedCells` set,
+   * so callers can decide how to apply the result.
+   *
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} anchor - Drag start cell (anchor cell).
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} focus - Current drag focus cell.
+   * @returns {(RTETableCellBlock | RTETableHeadCellBlock)[]} All cells in the rectangular selection area.
+   */
+  static computeRectRange(anchor: RTETableCellBlock | RTETableHeadCellBlock, focus: RTETableCellBlock | RTETableHeadCellBlock): (RTETableCellBlock | RTETableHeadCellBlock)[];
+  /**
+   * Get the rowSpan and colSpan attributes from a cell's DOM element.
+   *
+   * @param {RTETableCellBlock} cell - The cell to get span values from.
+   * @returns {CellSpanType} Object with rowSpan and colSpan properties.
+   */
+  private static getCellSpan;
+  /**
+   * Build a grid representation of the table that accounts for rowSpan and colSpan.
+   * Each cell in the grid array points to the actual cell block that occupies that position.
+   *
+   * @param {RTETableRowBlock[]} allRows - All rows in the table.
+   * @returns {CellGridMetaType} Object with grid and cellMeta properties.
+   */
+  private static buildCellGrid;
+  /**
+   * Clean up event listeners.
+   */
+  destroy(): void;
+  /**
+   * Inject the extension context and set up selection change listener.
+   *
+   * @param {RTEExtensionContext} context - The extension context.
+   */
+  init(context: RTEExtensionContext): void;
+  /**
+   * Set the selected cells to the given list, replacing any existing selection.
+   *
+   * @param {RTETableCellBlock} cells - The cells to select.
+   */
+  setSelectedCells(cells: RTETableCellBlock[]): void;
+  /**
+   * Get all currently selected cells.
+   *
+   * @returns {(RTETableCellBlock | RTETableHeadCellBlock)[]} A flat list of selected cells.
+   */
+  getSelectedCells(): (RTETableCellBlock | RTETableHeadCellBlock)[];
+  /**
+   * Handle mouse down on a cell: start drag selection from the given cell.
+   *
+   * @param {HTMLElement} cellRef - The cell where the drag starts.
+   */
+  focusCell(cellRef: HTMLElement): void;
+  /**
+   * Handle drag over a cell (typically called on `mouseenter` while dragging).
+   * Maintains a rectangular selection between the anchor cell and the current cell.
+   *
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} cell - The cell currently under the drag.
+   */
+  dragOver(cell: RTETableCellBlock | RTETableHeadCellBlock): void;
+  /**
+   * Handle mouse up: stop drag selection.
+   */
+  endDrag(): void;
+  /**
+   * Emit table-cell selection change notify for the owning table.
+   *
+   * @param {RTETableCellBlock} firstCell - First cell of the table.
+   * @param {RTETableCellBlock[]} cells - The current selected table cells.
+   */
+  private emitCellSelectionChange;
+  /**
+   * Clear the current selection state without changing the drag flag.
+   */
+  private clearSelection;
+  /**
+   * Add a selectionchange listener to the document to handle cell click selection.
+   */
+  private addSelectionChangeListener;
+  /**
+   * Remove the selectionchange listener from the document.
+   */
+  private removeSelectionChangeListener;
+  /**
+   * Handle selection change events from the document for the cell click selection.
+   */
+  private handleSelectionChange;
+  /**
+   * Recursively filter and collect selected table cell blocks within the given node.
+   *
+   * @param {Range} range - The current selection range.
+   * @param {Node} node - The current node to check for selection.
+   * @returns {RTETableCellBlock[]} A list of selected table cell blocks.
+   */
+  private filterSelectedCell;
+  /**
+   * Mark the beginning of a drag operation.
+   */
+  private startDrag;
+  /**
+   * Add the given cells to the current selection set.
+   *
+   * @param {RTETableCellBlock[]} cells - The cells to add to the selection.
+   * @param {{ debounceSync?: boolean }} [options] - Options for updating selection.
+   * @param {boolean} [options.debounceSync] - Whether to debounce the RTE selection sync.
+   */
+  private updateSelectedCells;
+  /**
+   * Update the styles of the selected cells.
+   *
+   * @param {RTETableCellBlock} cell - The cell to update style for.
+   * @param {number} total - The total number of selected cells.
+   */
+  private updateSelectedStyles;
+  /**
+   * Synchronizes the rich text editor selection with the selected table cells.
+   */
+  private syncRTESelection;
+  /**
+   * Prevents text selection during drag operations.
+   *
+   * @param {RTETableCellBlock[]} selectedCells - The currently selected table cells.
+   */
+  private preventTextSelection;
+  /**
+   * Adds a mouse up listener to the document to finish drag selection.
+   *
+   */
+  private addListeners;
+  /**
+   * Handles the document mouse up event to finish drag selection.
+   */
+  private handleDocMouseUp;
+  /**
+   * Resets the table selection when clicking outside the table.
+   */
+  private handleContentClick;
+}

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

@@ -0,0 +1,26 @@
+import { VegaRTECreateElementFunction, VegaRTEToolbarRenderContext, VegaRTERenderResult } from '../../interface';
+import { VegaRTEToolbarButtonRenderer } from '../base-toolbar-button-renderer';
+/**
+ * Function toolbar button renderer class.
+ */
+export declare class RTETableToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  /**
+   * @inheritDoc
+   */
+  render(h: VegaRTECreateElementFunction, editorContext: VegaRTEToolbarRenderContext): VegaRTERenderResult;
+  /**
+   * Overrides the isDisabled method to determine if the button should be disabled.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   * @returns {boolean} - true if the button should be disabled, false otherwise.
+   */
+  protected isDisabled(editorContext: VegaRTEToolbarRenderContext): boolean;
+  /**
+   * @inheritDoc
+   */
+  protected handleButtonClick(): void;
+  /**
+   * @inheritDoc
+   */
+  protected handleDropdownClick(): void;
+}