@heartlandone/vega 2.77.1 → 2.79.0

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

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

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

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

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

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

@@ -0,0 +1,74 @@
+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;
+  /**
+   * Analyze overlap between each cell and the delete range in a single pass.
+   * Returns fully covered cells (to delete) and partially covered cells (to adjust).
+   *
+   * @param {RTETableRowBlock[]} allRows - All rows in the table.
+   * @param {number} startCol - Start logical column to delete (inclusive).
+   * @param {number} endCol - End logical column to delete (inclusive).
+   * @param {string[][]} tableGrid - The 2D grid representation of the table.
+   * @returns {DeleteCellInfo} Overlap analysis for deletion and span adjustments.
+   */
+  private getDeleteCellsInfo;
+  /**
+   * Find the next focusable cell based on logical column position.
+   *
+   * @param {RTETableRowBlock[]} allTableRows - All table rows.
+   * @param {string[][]} tableGrid - The 2D grid representation.
+   * @param {number} startLogicalCol - Start of delete range.
+   * @param {number} endLogicalCol - End of delete range.
+   * @param {Set<string>} cellIdsToDelete - delete cell ids
+   * @param {number} anchorRowIndex - the anchor row index
+   * @returns {Nullable<RTETableCellBlock | RTETableHeadCellBlock>} The next focusable cell.
+   */
+  private findNextFocusableCell;
+  /**
+   * Find the next focusable cell ID in a grid row, skipping deleted cells.
+   *
+   * @param {string[]} gridRow - The grid row array.
+   * @param {number} startCol - Start logical column.
+   * @param {number} endCol - End logical column.
+   * @param {Set<string>} cellIdsToDelete - Set of cell IDs to skip.
+   * @returns {Nullable<string>} The next focusable cell ID, or null if none found.
+   */
+  private findFocusableCellIdInGridRow;
+  /**
+   * Deletes cells by adjusting partial cells and removing fully covered cells.
+   *
+   * @param {(RTETableCellBlock | RTETableHeadCellBlock)[]} coveredCells - Cells that should be fully removed.
+   * @param {AdjustmentCellInfo[]} partialAdjustments - Cells that need colspan reduction.
+   * @param {RTETableBlock} table - The table block.
+   */
+  private deleteCells;
+  /**
+   * Re-apply span attributes after deletion so remaining cells are normalized
+   * against the new table width. When colspan equals table column count, don't set rowspan.
+   *
+   * @param {RTETableBlock} table - The table block.
+   * @param {Set<string>} skipCellIds - The table skip cell`s id.
+   */
+  private normalizeRemainingCellSpans;
+  /**
+   * Get overlap count of two logical column ranges.
+   *
+   * @param {number} cellStartCol - Logical start column of the cell.
+   * @param {number} cellColSpan - Colspan value of the cell.
+   * @param {number} deleteStartCol - Start logical column of delete range.
+   * @param {number} deleteEndCol - End logical column of delete range.
+   * @returns {number} The number of overlapping logical columns.
+   */
+  private getColumnOverlapCount;
+}

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

@@ -0,0 +1,55 @@
+import { DeleteTableRowAction } from '../actions/delete-table-row-action';
+import { RTETableBlock } from '../dto/table-block';
+import { TableRowCommonUtilitiesStrategy } from './table-row-strategy.abstract';
+/**
+ * Strategy class for handling the deletion of table rows.
+ */
+export declare class DeleteTableRowStrategy extends TableRowCommonUtilitiesStrategy<DeleteTableRowAction, RTETableBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: DeleteTableRowAction, target: RTETableBlock): void;
+  /**
+   * Removes the specified rows from their parent table section.
+   * Handles rowspan adjustments when deleting rows that contain or are part of merged cells.
+   *
+   * Scenarios handled:
+   * 1. If all rows in a section are being removed, the entire section is removed.
+   * 2. If a cell with rowspan > 1 starts before the deleted rows and spans into them,
+   *    the rowspan is adjusted to exclude the deleted rows.
+   * 3. If a cell with rowspan > 1 starts in the first deleted row and spans beyond,
+   *    the cell is moved to the next remaining row with adjusted rowspan.
+   * 4. If a cell with rowspan is entirely within the deleted rows, it's removed with the rows.
+   *
+   * @param {RTETableRowBlock[]} rowsToBeRemoved - The rows to be removed.
+   */
+  private removeRows;
+  /**
+   * 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>} removalIndices - Indices of rows to remove.
+   * @param {number} firstRemovalIndex - First row index to remove.
+   * @param {number} lastRemovalIndex - Last row index to remove.
+   * @returns {Map<number, CellToMove[]>} Map of target row index to cells to move.
+   */
+  private collectCellsToMove;
+  /**
+   * Clones a table cell with a new rowspan value.
+   *
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} cell - The cell to clone.
+   * @param {number} newRowSpan - The new rowspan value for the cloned cell.
+   * @returns {RTETableCellBlock | RTETableHeadCellBlock} The cloned cell with updated rowspan.
+   */
+  private cloneCellWithRowSpan;
+  /**
+   * 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

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

@@ -0,0 +1,60 @@
+import { RTETableBlock } from '../dto/table-block';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+import { InsertTableColumnAction } from '../actions/insert-table-column-action';
+import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
+import { TableColumnStrategy } from './table-column-strategy.abstract';
+export declare type InsertPosition = {
+  anchorCell: RTETableCellBlock | RTETableHeadCellBlock;
+  templateCell: RTETableCellBlock | RTETableHeadCellBlock;
+  before: boolean;
+};
+/**
+ * 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;
+  /**
+   * Find a spanning cell that should absorb the inserted logical column by increasing colspan.
+   *
+   * @param {RTETableRowBlock} row - The row to check.
+   * @param {number} rowIndex - The row index in the grid.
+   * @param {number} targetCol - The target logical column.
+   * @param {string[][]} tableGrid - The table grid.
+   * @param {InsertTableColumnDirection} insertDirection - Insert direction.
+   * @param {Set<string>} selectedCellIds - The set of selected cell IDs.
+   * @param {boolean} hasSelectedCellInsideTargetCol - Whether any selected merged cell covers the target column internally.
+   * @returns {Nullable<RTETableCellBlock | RTETableHeadCellBlock>} Expandable cell or null.
+   */
+  private findExpandableCell;
+  /**
+   * Check whether any selected merged cell covers the target column internally.
+   *
+   * @param {RTETableRowBlock[]} allRows - All table rows.
+   * @param {string[][]} tableGrid - The 2D grid representation of the table.
+   * @param {number} targetCol - The target logical column.
+   * @param {Set<string>} selectedCellIds - The set of selected cell IDs.
+   * @returns {boolean} True if any selected cell internally covers the target column.
+   */
+  private hasSelectedCellInsideTargetColumn;
+  /**
+   * Find the correct cell and position to insert a new cell in a row.
+   *
+   * @param {RTETableRowBlock} row - The row to insert into.
+   * @param {number} rowIndex - The index of the row.
+   * @param {number} targetCol - The target logical column position.
+   * @param {string[][]} tableGrid - The 2D grid representation of the table.
+   * @param {RTETableRowBlock[]} allRows - All table rows.
+   * @returns {InsertPosition | null} The insert position or null.
+   */
+  private findInsertPosition;
+  /**
+   * 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-into-different-section-strategy.d.ts

@@ -0,0 +1,21 @@
+import { InsertTableRowIntoDifferentSectionAction } from '../actions/insert-table-row-into-different-section-action';
+import { RTETableBlock } from '../dto/table-block';
+import { TableRowCommonUtilitiesStrategy } from './table-row-strategy.abstract';
+/**
+ * Strategy class for handling the insertion of a new row into a table.
+ * The reference row is head row and the insert direction is below, so the new row will be inserted into the body section.
+ */
+export declare class InsertTableRowIntoDifferentSectionStrategy extends TableRowCommonUtilitiesStrategy<InsertTableRowIntoDifferentSectionAction, RTETableBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: InsertTableRowIntoDifferentSectionAction, target: RTETableBlock): void;
+  /**
+   * 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/insert-table-row-into-same-section-strategy.d.ts

@@ -0,0 +1,13 @@
+import { InsertTableRowIntoSameSectionAction } from '../actions/insert-table-row-into-same-section-action';
+import { RTETableBlock } from '../dto/table-block';
+import { TableRowCommonUtilitiesStrategy } from './table-row-strategy.abstract';
+/**
+ * Strategy class for handling the insertion of a new row into a table.
+ * The new row will be inserted in the same section (header or body) as the reference row based on the insert direction and the position of the selected rows.
+ */
+export declare class InsertTableRowIntoSameSectionStrategy extends TableRowCommonUtilitiesStrategy<InsertTableRowIntoSameSectionAction, RTETableBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: InsertTableRowIntoSameSectionAction): void;
+}

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