@heartlandone/vega 2.75.0-RTE-table-preview → 2.75.1

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

@@ -1,25 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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-strategies/delete-table-block-strategy.d.ts

@@ -1,14 +0,0 @@
-import type { RTEBlock } from '../../../dto/blocks/block.abstract';
-import type { DeleteTableBlockAction } from '../actions/delete-table-block-action';
-import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
-/**
- * Strategy to handle the deletion of a table block from the parent.
- */
-export declare class DeleteTableBlockStrategy extends ActionHandleStrategy<DeleteTableBlockAction, RTEBlock> {
-  /**
-   * Deletes the specified table block and updates the cursor position.
-   *
-   * @param {DeleteTableBlockAction} action - The action containing the table block to delete.
-   */
-  protected handleAction(action: DeleteTableBlockAction): void;
-}

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

@@ -1,31 +0,0 @@
-import { DeleteTableColumnAction } from '../actions/delete-table-column-action';
-import { RTETableBlock } from '../dto/table-block';
-import { TableColumnStrategy } from './table-column-strategy.abstract';
-/**
- * Strategy to handle the deletion of table column from the parent.
- */
-export declare class DeleteTableColumnStrategy extends TableColumnStrategy<DeleteTableColumnAction> {
-  /**
-   * Deletes the specified table column and updates the cursor position.
-   *
-   * @param {DeleteTableColumnAction} action - The action containing the table column to delete.
-   * @param {RTETableBlock} target - The target table block from which the column will be deleted.
-   */
-  protected handleAction(action: DeleteTableColumnAction, target: RTETableBlock): void;
-  /**
-   * Find the next focusable cell either after the deleted range or before it.
-   *
-   * @param {RTETableCellBlock[]} tableCellBlockDeleteRange - The range of table cell blocks to be deleted.
-   * @param {number[]} indexRange - The start and end indices of the cells to be deleted.
-   * @returns {Nullable<RTETableCellBlock | RTETableHeadCellBlock>} The next focusable cell.
-   */
-  private findNextFocusableCell;
-  /**
-   * Deletes cells in a given row from start index to end index.
-   *
-   * @param {RTETableRowBlock} row - The table row block.
-   * @param {number} startCellIndex - The start index of the cell to delete.
-   * @param {number} endCellIndex - The end index of the cell to delete.
-   */
-  private deleteCellsInRow;
-}

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

@@ -1,28 +0,0 @@
-import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
-import { DeleteTableRowAction } from '../actions/delete-table-row-action';
-import { RTETableBlock } from '../dto/table-block';
-/**
- * Strategy class for handling the deletion of table rows.
- */
-export declare class DeleteTableRowStrategy extends ActionHandleStrategy<DeleteTableRowAction, RTETableBlock> {
-  /**
-   * @inheritDoc
-   */
-  protected handleAction(action: DeleteTableRowAction, target: RTETableBlock): void;
-  /**
-   * Removes the specified row from its parent table section.
-   * // TODO: Add handling for when selected row has or in merge column.
-   *
-   * @param {RTETableRowBlock} rowToBeRemoved The row to be removed.
-   */
-  private removeRow;
-  /**
-   * Get the future focus row after deletion.
-   *
-   * @param {RTETableRowBlock} startRow - The first row to be deleted.
-   * @param {RTETableRowBlock} endRow - The last row to be deleted.
-   * @param {RTETableBlock} table - The table containing the rows.
-   * @returns {Nullable<RTETableRowBlock>} The row to be focused after deletion.
-   */
-  private getFutureFocusRow;
-}

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

@@ -1,27 +0,0 @@
-import type { RTEBlock } from '../../../dto/blocks/block.abstract';
-import { InsertTableBlockAction } from '../actions/insert-table-block-action';
-import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
-/**
- * Strategy to handle the insertion of a block into the rich text editor.
- */
-export declare class InsertTableBlockStrategy extends ActionHandleStrategy<InsertTableBlockAction, RTEBlock> {
-  /**
-   * @inheritDoc
-   */
-  protected handleAction(action: InsertTableBlockAction, target: RTEBlock): void;
-  /**
-   * Create a table block with the specified number of rows and columns.
-   *
-   * @param {number} row - The number of rows in the table.
-   * @param {number} column - The number of columns in the table.
-   * @returns {RTETableBlock} The created table block.
-   */
-  private createTableBlock;
-  /**
-   * We need to get the correct block if the current target is a block element to avoid nesting blocks.
-   *
-   * @param {RTEBlock} currentTarget - The current target block or content.
-   * @returns {Nullable<RTEBlock>} The reference block.
-   */
-  private getReferenceBlock;
-}

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

@@ -1,19 +0,0 @@
-import { RTETableBlock } from '../dto/table-block';
-import { InsertTableColumnAction } from '../actions/insert-table-column-action';
-import { TableColumnStrategy } from './table-column-strategy.abstract';
-/**
- * Strategy to handle the insertion of a table column into the RTETable.
- */
-export declare class InsertTableColumnStrategy extends TableColumnStrategy<InsertTableColumnAction> {
-  /**
-   * @inheritDoc
-   */
-  protected handleAction(action: InsertTableColumnAction, target: RTETableBlock): void;
-  /**
-   * Generate a new table cell based on the original cell type.
-   *
-   * @param {RTETableCellBlock | RTETableHeadCellBlock} originalCell The original table cell block to base the new cell on.
-   * @returns {RTETableCellBlock | RTETableHeadCellBlock} The newly generated table cell block.
-   */
-  private generateTableCell;
-}

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

@@ -1,44 +0,0 @@
-import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
-import { InsertTableRowAction } from '../actions/insert-table-row-action';
-import { RTETableBlock } from '../dto/table-block';
-/**
- * Strategy class for handling the insertion of a new row into a table.
- */
-export declare class InsertTableRowStrategy extends ActionHandleStrategy<InsertTableRowAction, RTETableBlock> {
-  /**
-   * @inheritDoc
-   */
-  protected handleAction(action: InsertTableRowAction, target: RTETableBlock): void;
-  /**
-   * 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;
-  /**
-   * 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.
-   */
-  private getDefaultCellBlockTemplate;
-  /**
-   * 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.
-   */
-  private getHeadCellLength;
-  /**
-   * Create table cells based on reference row and head cell length.
-   *
-   * @param {RTETableRowBlock} refRow - The reference table row block.
-   * @param {number} headCellLength - The length of the head cells.
-   * @returns {VegaRTETableCellBlock[]} An array of table cell blocks.
-   */
-  private createTableCells;
-}

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

@@ -1,38 +0,0 @@
-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/select-table-column-strategy.d.ts

@@ -1,12 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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/table-column-strategy.abstract.d.ts

@@ -1,20 +0,0 @@
-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';
-/**
- * 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.
-   * @returns {[number, number]} A tuple containing the start and end indices.
-   */
-  protected getBoundaryCellIndexOfRow(cellRange: (RTETableCellBlock | RTETableHeadCellBlock)[]): [number, number];
-}

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

@@ -1,41 +0,0 @@
-import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
-import { ToggleHeaderRowAction } from '../actions/toggle-header-row-action';
-import { RTETableBlock } from '../dto/table-block';
-/**
- * Strategy class for handling converting selected rows to header rows or reverting them back to normal rows.
- */
-export declare class ToggleHeaderRowStrategy extends ActionHandleStrategy<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 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;
-  /**
-   * 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.
-   *
-   * @param {RTETableRowBlock} row - The table row block containing the cells.
-   * @param {Nullable<RTETableRowBlock>} referenceRow - The reference row for comparison.
-   * @returns {RTETableCellBlock[]} The converted table body cell blocks.
-   */
-  private convertThToTd;
-}

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

@@ -1,45 +0,0 @@
-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 selected cells are header cells.
-   *
-   * @param {(RTETableCellBlock | RTETableHeadCellBlock)[]} selectedCellRange - The range of selected table cell blocks.
-   * @returns {boolean} True if all selected cells are header cells, false otherwise.
-   */
-  static isFullHeaderSelection(selectedCellRange: (RTETableCellBlock | RTETableHeadCellBlock)[]): boolean;
-  /**
-   * @inheritDoc
-   */
-  protected handleAction(action: ToggleHeaderTableColumnAction, target: RTETableBlock): void;
-  /**
-   * Toggles the specified header cells in a row to cells.
-   *
-   * @param {number} firstTableCellIndex - The index of the first table cell in the row.
-   * @param {RTETableRowBlock} row - The table row block containing the cells to toggle.
-   * @param {number} startCellIndex - The index of the first cell to toggle.
-   */
-  private toggleHeaderCellsToCells;
-  /**
-   * Toggles the specified cells in a row to header cells.
-   *
-   * @param {number} firstTableCellIndex - The index of the first table cell in the row.
-   * @param {number} endCellIndex - The index of the last cell to toggle.
-   * @param {RTETableRowBlock} row - The table row block containing the cells to toggle.
-   */
-  private toggleCellsToHeader;
-  /**
-   * Replaces a cell in a given row at the specified index with a new cell.
-   *
-   * @param {RTETableRowBlock} row - The table row block containing the cell to replace.
-   * @param {RTETableCellBlock | RTETableHeadCellBlock} oldCell - The cell to replace.
-   * @param {RTETableCellBlock | RTETableHeadCellBlock} newCell - The new cell to insert.
-   */
-  private replaceCellInRow;
-}

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

@@ -1,13 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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/delete-table-block-action.d.ts

@@ -1,12 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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-action.d.ts

@@ -1,23 +0,0 @@
-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 enum InsertTableRowDirection {
-  ABOVE = "ABOVE",
-  BELOW = "BELOW"
-}
-/**
- * Action class for inserting a new row into a table within the rich text editor.
- */
-export declare class InsertTableRowAction extends ModifyContentAction {
-  isFlushable: boolean;
-  type: string;
-  insertDirection: InsertTableRowDirection;
-  selectedRows: RTETableRowBlock[];
-  /**
-   * Constructs an InsertTableRowAction.
-   *
-   * @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[]);
-}