@heartlandone/vega 2.78.0 → 2.80.0

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/merge-cells-strategy.d.ts

@@ -0,0 +1,38 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { MergeCellsAction } from '../actions/merge-cells-action';
+import { RTETableBlock } from '../dto/table-block';
+/**
+ * Strategy to handle the merging of table cells.
+ */
+export declare class MergeCellsStrategy extends ActionHandleStrategy<MergeCellsAction, RTETableBlock> {
+  /**
+   * Handles the merge cells action.
+   *
+   * @param {MergeCellsAction} action - The action containing merge details.
+   * @param {RTETableBlock} target - The target table block.
+   */
+  protected handleAction(action: MergeCellsAction, target: RTETableBlock): void;
+  /**
+   * Merge content from all selected cells to the target cell.
+   *
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} targetCell - The target cell.
+   * @param {RTETableCellBlock[] | RTETableHeadCellBlock[]} selectedCells - All selected cells.
+   */
+  private mergeContentToTargetCell;
+  /**
+   * Delete all selected cells except the target cell.
+   *
+   * @param {RTETableCellBlock[] | RTETableHeadCellBlock[]} selectedCells - All selected cells.
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} targetCell - The target cell (should not be deleted).
+   */
+  private deleteOtherSelectedCells;
+  /**
+   * Remove rowSpan from all cells in the target row when every cell shares the same rowSpan.
+   * This avoids keeping stale row spans after a merge operation that no longer spans rows.
+   *
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} targetCell - The target cell to set attributes on.
+   * @param {RTETableBlock} table - The table block.
+   * @param {number} targetCellRowSpan - The target cell rowSpan.
+   */
+  private clearRowSpanIfUniformAcrossRow;
+}

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

@@ -0,0 +1,12 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { ReplaceTableCellAction } from '../actions/replace-table-cell-action';
+import { RTETableRowBlock } from '../dto/table-row-block';
+/**
+ * Strategy to replace a fully overlapped table cell.
+ */
+export declare class ReplaceTableCellStrategy extends ActionHandleStrategy<ReplaceTableCellAction, RTETableRowBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: ReplaceTableCellAction, row: RTETableRowBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/select-table-column-strategy.d.ts

@@ -0,0 +1,12 @@
+import { RTETableBlock } from '../dto/table-block';
+import { SelectTableColumnAction } from '../actions/select-table-column-action';
+import { TableColumnStrategy } from './table-column-strategy.abstract';
+/**
+ * Strategy to handle the selection of a table column.
+ */
+export declare class SelectTableColumnStrategy extends TableColumnStrategy<SelectTableColumnAction> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: SelectTableColumnAction, target: RTETableBlock): void;
+}

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

@@ -0,0 +1,43 @@
+import { RTETableCellBlock } from '../dto/table-cell-block';
+import { SplitCellHorizontallyAction } from '../actions/split-cell-horizontally-action';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+/**
+ * Strategy to handle horizontal split of a table cell (splits top/bottom).
+ */
+export declare class SplitCellHorizontallyStrategy extends ActionHandleStrategy<SplitCellHorizontallyAction, RTETableCellBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(_action: SplitCellHorizontallyAction, target: RTETableCellBlock): void;
+  /**
+   * Find the correct insertion position for a cell at a given column position in a row.
+   * Accounts for cells from previous rows with rowspan extending into the target row.
+   *
+   * @param {RTETableRowBlock} targetRow - The row to insert into.
+   * @param {number} targetColumnPosition - The target column position.
+   * @param {RTETableRowBlock[]} allRows - All rows in the table.
+   * @param {number} rowIndex - The index of the target row.
+   * @returns {number} The physical cell index to insert at.
+   */
+  private findInsertPosition;
+  /**
+   * Create a new row with only the bottom cell.
+   * Other columns will be covered by cells from the original row with increased rowSpan.
+   *
+   * @param {RTETableBodyBlock | RTETableHeadBlock} section - The section (thead or tbody).
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} bottomCell - The bottom cell to insert.
+   * @returns {RTETableRowBlock} The newly created row.
+   */
+  private createNewRowWithCell;
+  /**
+   * Update all cells from all previous rows that span through the newly inserted row.
+   * When a new row is inserted at `insertionRowIndex`, any cell from a previous row
+   * that has rowSpan extending to or beyond that position needs rowSpan increased by 1.
+   *
+   * @param {RTETableRowBlock[]} allRows - All rows in the table (after insertion).
+   * @param {number} insertionRowIndex - The index where the new row was inserted.
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} splitCell - The cell that was split (skip this one).
+   * @param {RTETableBlock} table - The table block.
+   */
+  private updateCellsSpanningThroughInsertionPoint;
+}

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

@@ -0,0 +1,27 @@
+import { RTETableCellBlock } from '../dto/table-cell-block';
+import { SplitCellVerticallyAction } from '../actions/split-cell-vertically-action';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+/**
+ * Strategy to handle vertical split of a table cell (splits left/right).
+ */
+export declare class SplitCellVerticallyStrategy extends ActionHandleStrategy<SplitCellVerticallyAction, RTETableCellBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(_action: SplitCellVerticallyAction, target: RTETableCellBlock): void;
+  /**
+   * Update cells in other rows to account for the new columns added by the split.
+   * When a cell is split vertically and new columns are added to the table,
+   * cells in other rows that span across the position where the split happened
+   * need their colSpan increased.
+   *
+   * @param {RTETableRowBlock[]} allRows - All rows in the table.
+   * @param {number} splitRowIndex - The index of the row containing the split cell.
+   * @param {number} splitColumnStart - The starting column position of the split cell.
+   * @param {number} splitColumnEnd - The ending column position of the split cell.
+   * @param {number} splitCellRowSpan - The rowSpan of the split cell.
+   * @param {number} newColumnsAdded - The number of new columns added by the split.
+   * @param {RTETableBlock} table - The table block.
+   */
+  private updateOtherRowsCells;
+}

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

@@ -0,0 +1,12 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { SplitTableCellAction } from '../actions/split-table-cell-action';
+import { RTETableRowBlock } from '../dto/table-row-block';
+/**
+ * Strategy to split a partially overlapped table cell.
+ */
+export declare class SplitTableCellStrategy extends ActionHandleStrategy<SplitTableCellAction, RTETableRowBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: SplitTableCellAction, row: RTETableRowBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/table-column-strategy.abstract.d.ts

@@ -0,0 +1,23 @@
+import type { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import type { RTETableCellBlock } from '../dto/table-cell-block';
+import type { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { AnnotationAction } from '../../../dto/actions/annotation-action.abstract';
+import { RTETableRowBlock } from '../dto/table-row-block';
+/**
+ * Abstract base strategy for handling table column operations.
+ * Provides common functionality for all column-related strategies.
+ */
+export declare abstract class TableColumnStrategy<TAction extends ModifyContentAction | AnnotationAction> extends ActionHandleStrategy<TAction, RTEBlock> {
+  /**
+   * Finds the index range of cells within a table row.
+   * Returns the start and end indices of the given cell range.
+   *
+   * @param {(RTETableCellBlock | RTETableHeadCellBlock)[]} cellRange - The range of table cells to find indices for.
+   * @param {RTETableRowBlock[]} allTableRows - All table rows.
+   * @param {string[][]} grid - The 2D grid representation of the table
+   * @returns {[number, number]} A tuple containing the start and end indices.
+   */
+  protected getBoundaryCellColumnRange(cellRange: (RTETableCellBlock | RTETableHeadCellBlock)[], allTableRows: RTETableRowBlock[], grid: string[][]): [number, number];
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/table-row-strategy.abstract.d.ts

@@ -0,0 +1,120 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTETableBlock } from '../dto/table-block';
+import { RTETableCellBlock, VegaRTETableCellBlock } from '../dto/table-cell-block';
+import { RTETableHeadCellBlock, VegaRTETableHeadCellBlock } from '../dto/table-head-cell-block';
+import { RTETableRowBlock } from '../dto/table-row-block';
+export declare type CellToMove = {
+  cell: RTETableCellBlock | RTETableHeadCellBlock;
+  newRowSpan: number;
+  cellIndex: number;
+  logicalStartCol: number;
+};
+export declare type LogicalStartSpanCell = {
+  cell?: RTETableCellBlock;
+  rowIndex: number;
+};
+/**
+ * Abstract base strategy for table row actions. Provides common utilities for row manipulations.
+ */
+export declare abstract class TableRowCommonUtilitiesStrategy<A extends ModifyContentAction, T extends RTETableBlock> extends ActionHandleStrategy<A, T> {
+  static readonly DEFAULT_CELLSPAN: number;
+  /**
+   * Calculates the maximum number of cells in any row, accounting for colSpan.
+   *
+   * @param {RTETableRowBlock[]} rows - The rows to analyze.
+   * @returns {number} The maximum cell count across the rows.
+   */
+  protected getRowsMaxCellCount(rows: RTETableRowBlock[]): number;
+  /**
+   * Compute logical start columns for each row's cells, accounting for colSpan and rowSpan.
+   *
+   * @param {RTETableRowBlock[]} rows - Table rows in a section.
+   * @returns {number[][]} Array of row cell start columns by cell index.
+   */
+  protected getRowCellStartCols(rows: RTETableRowBlock[]): number[][];
+  /**
+   * Updates the rowspan/colspan attribute of a table cell.
+   *
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} cell - The cell to update.
+   * @param {'rowspan' | 'colspan'} spanKey - The attribute key to update.
+   * @param {number} newSpan - The new rowspan/colspan value.
+   */
+  protected updateCellSpan(cell: RTETableCellBlock | RTETableHeadCellBlock, spanKey: 'rowspan' | 'colspan', newSpan: number): void;
+  /**
+   * Insert moved cells into target rows using logical column positions.
+   *
+   * @param {Map<number, CellToMove[]>} cellsToMove - Cells grouped by target row.
+   * @param {RTETableRowBlock[]} allRows - All rows in the section.
+   * @param {number[][]} rowCellStartCols - Logical start columns per row.
+   */
+  protected insertMovedCells(cellsToMove: Map<number, CellToMove[]>, allRows: RTETableRowBlock[], rowCellStartCols: number[][]): void;
+  /**
+   * Splits the selected rows into head rows and body rows.
+   *
+   * @param {RTETableRowBlock[]} rows - The rows to be split.
+   * @returns {RTETableRowBlock[][]} - An array containing two arrays: the first with head rows and the second with body rows.
+   */
+  protected splitRowsBySection(rows: RTETableRowBlock[]): RTETableRowBlock[][];
+  /**
+   * Build indices for selected rows within the section.
+   *
+   * @param {RTETableRowBlock[]} selectedRows - Selected rows.
+   * @param {RTETableRowBlock[]} allRows - All rows in the section.
+   * @returns {Set<number>} The set of selected row indices.
+   */
+  protected buildSelectedIndices(selectedRows: RTETableRowBlock[], allRows: RTETableRowBlock[]): Set<number>;
+  /**
+   * Determine whether a cell's row span intersects the removal range.
+   *
+   * @param {number} cellStartIndex - Cell start row index.
+   * @param {number} cellEndIndex - Cell end row index.
+   * @param {number} firstRemovalIndex - First row index to remove.
+   * @param {number} lastRemovalIndex - Last row index to remove.
+   * @returns {boolean} True if the ranges intersect.
+   */
+  protected intersectsRemovalRange(cellStartIndex: number, cellEndIndex: number, firstRemovalIndex: number, lastRemovalIndex: number): boolean;
+  /**
+   * Count how many rows in the cell span are being removed.
+   *
+   * @param {number} cellStartIndex - Cell start row index.
+   * @param {number} cellEndIndex - Cell end row index.
+   * @param {Set<number>} removalIndices - Indices of rows to remove.
+   * @returns {number} Count of removed rows in the span.
+   */
+  protected countRemovedRows(cellStartIndex: number, cellEndIndex: number, removalIndices: Set<number>): number;
+  /**
+   * Get the column head end index in a table row.
+   *
+   * @param {RTETableRowBlock} tableRow - The table row block.
+   * @returns {number} The end index of the column head.
+   */
+  protected getHeadCellLength(tableRow: RTETableRowBlock): number;
+  /**
+   * Gets the starting cell for a given cell index by checking row spans.
+   *
+   * @param {RTETableRowBlock[]} allRows - All rows in the section to check for row spans.
+   * @param {number[][]} rowsStartCols - Pre-calculated starting column indices for each cell in each row.
+   * @param {number} rowIndex - The index of the row to start checking from.
+   * @param {number} cellIndex - The logical cell index to find the starting cell for.
+   * @returns {LogicalStartSpanCell} - The starting cell and its row index if found, otherwise the cell is undefined.
+   */
+  protected getTheStartSpanCell(allRows: RTETableRowBlock[], rowsStartCols: number[][], rowIndex: number, cellIndex: number): LogicalStartSpanCell;
+  /**
+   * Get the default cell block template.
+   *
+   * @param {string} cellType - The type of the cell block.
+   * @param {number} colSpan - The colspan attribute for the cell.
+   * @param {number} rowSpan - The rowspan attribute for the cell.
+   * @returns {VegaRTETableCellBlock | VegaRTETableHeadCellBlock} The default cell block template.
+   */
+  protected getDefaultCellBlockTemplate(cellType: string, colSpan: number, rowSpan?: number): VegaRTETableCellBlock | VegaRTETableHeadCellBlock;
+  /**
+   * Convert a numeric-keyed map to an array sorted by ascending key.
+   *
+   * @typedef T - The type of the values in the map.
+   * @param {Map<number, T>} valueMap - The map with numeric keys to convert.
+   * @returns {T[]} An array of values sorted by their numeric keys.
+   */
+  protected getSortedValuesByNumericKey<T>(valueMap: Map<number, T>): T[];
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/toggle-header-row-strategy.d.ts

@@ -0,0 +1,86 @@
+import { ToggleHeaderRowAction } from '../actions/toggle-header-row-action';
+import { RTETableBlock } from '../dto/table-block';
+import { TableRowCommonUtilitiesStrategy } from './table-row-strategy.abstract';
+/**
+ * Strategy class for handling converting selected rows to header rows or reverting them back to normal rows.
+ */
+export declare class ToggleHeaderRowStrategy extends TableRowCommonUtilitiesStrategy<ToggleHeaderRowAction, RTETableBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: ToggleHeaderRowAction, target: RTETableBlock): void;
+  /**
+   * Converts normal rows to header rows.
+   *
+   * @param {RTETableRowBlock[]} rows - The table row blocks to convert.
+   * @param {RTETableBlock} table - The table block containing the rows.
+   */
+  private convertToHeaderRows;
+  /**
+   * Converts body rows to header rows.
+   *
+   * @param {RTETableBodyBlock} tableBody - The table body block containing the rows to be converted.
+   * @param {RTETableHeadBlock} tableHead - The table head block to which the rows will be moved.
+   * @param {RTETableRowBlock[]} shouldConvertRows - The rows to be converted.
+   */
+  private convertBodyRowsToHeaderRows;
+  /**
+   * Converts header rows back to normal rows.
+   *
+   * @param {RTETableRowBlock[]} rows - The table row blocks to convert.
+   * @param {RTETableBlock} table - The table block containing the rows.
+   */
+  private revertToBodyRows;
+  /**
+   * Convert header rows to body rows.
+   *
+   * @param {RTETableHeadBlock} tableHead - The table head block containing the rows to be converted.
+   * @param {RTETableBodyBlock} tableBody - The table body block to which the rows will be moved.
+   * @param {RTETableRowBlock[]} shouldConvertRows - The rows to be converted.
+   */
+  private convertHeadRowsToBodyRows;
+  /**
+   * Collect cells that need to be moved to the next remaining row.
+   *
+   * @param {RTETableRowBlock[]} allRows - All rows in the section.
+   * @param {number[][]} rowCellStartCols - Logical start columns per row.
+   * @param {Set<number>} selectedIndices - Indices of selected rows.
+   * @param {number} firstSelectedIndex - First selected row index.
+   * @param {number} lastSelectedIndex - Last selected row index.
+   * @returns {Map<number, CellToMove[]>} Map of target row index to cells to move.
+   */
+  private collectCellsToMove;
+  /**
+   * Converts a table data cell to a table header cell.
+   *
+   * @param {RTETableHeadCellBlock} cell - The table cell block to convert.
+   * @returns {RTETableHeadCellBlock} The converted table header cell block.
+   */
+  private convertTdToTh;
+  /**
+   * Converts table header cells to table body cells.
+   * Need to check each cell's logical column index to determine whether it should be converted or not.
+   *
+   * @param {RTETableRowBlock} row - The table row block containing the cells.
+   * @param {number[]} rowCellStartCol - The starting column indices for each cell in the row.
+   * @param {number} headCellLength - The number of header cells in the reference row.
+   * @returns {RTETableCellBlock[]} The converted table body cell blocks.
+   */
+  private convertThToTd;
+  /**
+   * Clones a table cell with a new rowspan value, used when moving cells during row conversion.
+   * For example, when converting body rows contains a cell with rowspan, we need to clone a new empty cell with same colspan and insert it into the remaining row, and update the original cell's rowspan to make sure the table structure is correct after conversion.
+   *
+   * @param {RTETableCellBlock} cell - The cell to clone.
+   * @param {number} newRowSpan - The new rowspan value for the cloned cell.
+   * @returns {RTETableCellBlock} The cloned cell with updated rowspan.
+   */
+  private cloneCellWithRowSpan;
+  /**
+   * Delete the default background color annotation from a header cell when converting it to a body cell.
+   *
+   * @param {VegaRTETableHeadCellBlock} cell - The table head cell block to process.
+   * @returns {VegaRTETableCellBlock} The processed table cell block with default background color annotation removed if applicable.
+   */
+  private deleteHeadCellDefaultBackground;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/toggle-header-table-column-strategy.d.ts

@@ -0,0 +1,55 @@
+import { RTETableBlock } from '../dto/table-block';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
+import { ToggleHeaderTableColumnAction } from '../actions/toggle-header-table-column-action';
+import { TableColumnStrategy } from './table-column-strategy.abstract';
+/**
+ * Strategy to handle the toggle of header state of a table column.
+ */
+export declare class ToggleHeaderTableColumnStrategy extends TableColumnStrategy<ToggleHeaderTableColumnAction> {
+  /**
+   * Check if all cells in the column containing the selected cell are head cells.
+   *
+   * @param {(RTETableCellBlock | RTETableHeadCellBlock)[]} selectedCellRange - The range of selected table cell blocks.
+   * @returns {boolean} True if all cells in the column containing the selected cell are head cells, false otherwise.
+   */
+  static isFullHeaderSelection(selectedCellRange: (RTETableCellBlock | RTETableHeadCellBlock)[]): boolean;
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: ToggleHeaderTableColumnAction, target: RTETableBlock): void;
+  /**
+   * Toggle header cells within existing table-head rows.
+   *
+   * @param {RTETableBlock} table - The target table block.
+   * @param {RTETableRowBlock[]} allTableRows - All table rows in order.
+   * @param {string[][]} tableGrid - Table grid representation.
+   * @param {boolean} headerOn - Whether header mode is being enabled.
+   * @param {number} maxSelectCellCol - Maximum selected logical column.
+   * @param {number} minSelectCellCol - Minimum selected logical column.
+   */
+  private toggleHeadRows;
+  /**
+   * Toggle header cells within body rows.
+   *
+   * @param {RTETableBlock} table - The target table block.
+   * @param {RTETableRowBlock[]} allTableRows - All table rows in order.
+   * @param {string[][]} tableGrid - Table grid representation.
+   * @param {boolean} headerOn - Whether header mode is being enabled.
+   * @param {number} minSelectCellCol - Minimum selected logical column.
+   * @param {number} maxSelectCellCol - Maximum selected logical column.
+   */
+  private toggleBodyRows;
+  /**
+   * Toggle cell types in a row within a logical column range.
+   *
+   * @param {RTETableBlock} table - The table block containing the target row.
+   * @param {RTETableRowBlock} row - The table row block.
+   * @param {string[]} gridRow - The grid row array.
+   * @param {number} startCol - Start logical column.
+   * @param {number} endCol - End logical column.
+   * @param {(cell: RTETableCellBlock | RTETableHeadCellBlock) => boolean} shouldConvert - Predicate to determine if a cell should be converted.
+   * @param {(cell: RTETableCellBlock | RTETableHeadCellBlock) => RTETableCellBlock | RTETableHeadCellBlock} convert - Function to convert the cell.
+   */
+  private toggleCellType;
+}

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

@@ -0,0 +1,13 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { RTETableCellAnnotationsAction } from '../actions/table-cell-annotations-action';
+import { RTETableHeadCellAnnotationsAction } from '../actions/table-head-cell-annotations-action';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+/**
+ * Update table cell properties action handler strategy
+ */
+export declare class UpdateTableCellPropertiesStrategy extends ActionHandleStrategy<RTETableCellAnnotationsAction | RTETableHeadCellAnnotationsAction, RTETableCellBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: RTETableCellAnnotationsAction | RTETableHeadCellAnnotationsAction, target: RTETableCellBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/update-table-properties-strategy.d.ts

@@ -0,0 +1,12 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { UpdateTablePropertiesAction } from '../actions/update-table-properties-action';
+import { RTETableBlock } from '../dto/table-block';
+/**
+ * Update table properties action handler strategy
+ */
+export declare class UpdateTablePropertiesStrategy extends ActionHandleStrategy<UpdateTablePropertiesAction, RTETableBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: UpdateTablePropertiesAction, target: RTETableBlock): void;
+}

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

@@ -0,0 +1,21 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTETableBlock } from '../dto/table-block';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
+export declare const CREATE_SEGMENT_TABLE_CELL: string;
+export interface CreateSegmentTableCellActionPayload {
+  table: RTETableBlock;
+  sourceCell: RTETableCellBlock | RTETableHeadCellBlock;
+  colSpan: number;
+  cellType: string;
+  keepSourceContent: boolean;
+}
+/**
+ * Action to create a split segment table cell.
+ */
+export declare class CreateSegmentTableCellAction extends ModifyContentAction {
+  isFlushable: boolean;
+  type: string;
+  payload: CreateSegmentTableCellActionPayload;
+  constructor(payload: CreateSegmentTableCellActionPayload);
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/delete-table-block-action.d.ts

@@ -0,0 +1,12 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import type { RTETableBlock } from '../dto/table-block';
+export declare const DELETE_TABLE_BLOCK: string;
+/**
+ * Action to delete a table block
+ */
+export declare class DeleteTableBlockAction extends ModifyContentAction {
+  isFlushable: boolean;
+  type: string;
+  tableBlock: RTETableBlock;
+  constructor(target: RTETableBlock);
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/delete-table-column-action.d.ts

@@ -0,0 +1,15 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+export declare const DELETE_TABLE_COLUMN: string;
+/**
+ * Action to delete a table column
+ */
+export declare class DeleteTableColumnAction extends ModifyContentAction {
+  isFlushable: boolean;
+  type: string;
+  /**
+   * The table cell delete range that determines which column to delete.
+   */
+  tableCellDeleteRange: RTETableCellBlock[];
+  constructor(target: RTETableCellBlock[]);
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/delete-table-row-action.d.ts

@@ -0,0 +1,17 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTETableRowBlock } from '../dto/table-row-block';
+export declare const DELETE_TABLE_ROW: string;
+/**
+ * Action class for deleting a specific table row.
+ */
+export declare class DeleteTableRowAction extends ModifyContentAction {
+  isFlushable: boolean;
+  type: string;
+  rowsToBeRemoved: RTETableRowBlock[];
+  /**
+   * Constructs an InsertTableRowAction.
+   *
+   * @param {RTETableRowBlock[]} rowsToBeRemoved - The rows to be removed from the table.
+   */
+  constructor(rowsToBeRemoved: RTETableRowBlock[]);
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/insert-table-block-action.d.ts

@@ -0,0 +1,20 @@
+import { Nullable } from '../../../../../types/general';
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+export declare const INSERT_TABLE_BLOCK: string;
+/**
+ * Action to insert a table block into the rich text editor.
+ */
+export declare class InsertTableBlockAction extends ModifyContentAction {
+  type: string;
+  nextFocusNode: Nullable<RTENode>;
+  /**
+   * Number of rows in the table.
+   */
+  rowCount: number;
+  /**
+   * Number of columns in the table.
+   */
+  columnCount: number;
+  constructor(rowCount: number, columnCount: number);
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/insert-table-column-action.d.ts

@@ -0,0 +1,23 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+export declare const INSERT_TABLE_COLUMN: string;
+export declare enum InsertTableColumnDirection {
+  LEFT = "LEFT",
+  RIGHT = "RIGHT"
+}
+/**
+ * Action to insert a table column into the RTETable.
+ */
+export declare class InsertTableColumnAction extends ModifyContentAction {
+  isFlushable: boolean;
+  type: string;
+  /**
+   * The table cell insert range that determines where to insert the new column.
+   */
+  tableCellInsertRange: RTETableCellBlock[];
+  /**
+   * Specifies whether to insert the column to the left or right of the given cell range.
+   */
+  insertDirection: InsertTableColumnDirection;
+  constructor(insertDirection: InsertTableColumnDirection, tableCellInsertRange: RTETableCellBlock[]);
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/insert-table-row-into-different-section-action.d.ts

@@ -0,0 +1,20 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTETableRowBlock } from '../dto/table-row-block';
+import { InsertTableRowDirection } from './insert-table-row-into-same-section-action';
+export declare const INSERT_TABLE_ROW_INTO_DIFFERENT_SECTION: string;
+/**
+ * Action class for inserting a new row into a table within the rich text editor.
+ */
+export declare class InsertTableRowIntoDifferentSectionAction extends ModifyContentAction {
+  isFlushable: boolean;
+  type: string;
+  insertDirection: InsertTableRowDirection;
+  selectedRows: RTETableRowBlock[];
+  /**
+   * Constructs an InsertTableRowIntoDifferentSectionAction.
+   *
+   * @param {InsertTableRowDirection} insertDirection - The direction to insert the new row (above or below the current row).
+   * @param {RTETableRowBlock[]} selectedRows - The currently selected rows in the table.
+   */
+  constructor(insertDirection: InsertTableRowDirection, selectedRows?: RTETableRowBlock[]);
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/insert-table-row-into-same-section-action.d.ts

@@ -0,0 +1,24 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTETableRowBlock } from '../dto/table-row-block';
+export declare const INSERT_TABLE_ROW: string;
+export declare const INSERT_TABLE_ROW_INTO_SAME_SECTION: string;
+export declare enum InsertTableRowDirection {
+  ABOVE = "ABOVE",
+  BELOW = "BELOW"
+}
+/**
+ * Action class for inserting a new row into a table within the rich text editor.
+ */
+export declare class InsertTableRowIntoSameSectionAction extends ModifyContentAction {
+  isFlushable: boolean;
+  type: string;
+  insertDirection: InsertTableRowDirection;
+  selectedRows: RTETableRowBlock[];
+  /**
+   * Constructs an InsertTableRowIntoSameSectionAction.
+   *
+   * @param {InsertTableRowDirection} insertDirection - The direction to insert the new row (above or below the current row).
+   * @param {RTETableRowBlock[]} selectedRows - The currently selected rows in the table.
+   */
+  constructor(insertDirection: InsertTableRowDirection, selectedRows?: RTETableRowBlock[]);
+}