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

package/dist/collection/components/vega-rich-text-editor/extensions/table/action-handler-strategies/split-cell-horizontally-strategy.js

@@ -1,143 +0,0 @@
-import { RTETableRowBlock } from '../dto/table-row-block';
-import { RTETableBlock } from '../dto/table-block';
-import { InsertChildrenAfterAction } from '../../../dto/actions/insert-children-after-block';
-import { getCellSpan, getAllTableRows, getActualColumnPosition, getParentBlockByType, setSpanAttributes, createNewCell, } from '../utils/utils';
-import { generateUUID } from '../../../../../utils/misc';
-import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
-/**
- * Strategy to handle horizontal split of a table cell (splits top/bottom).
- */
-export class SplitCellHorizontallyStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(_action, target) {
-    const row = target.parent;
-    const section = row.parent;
-    const table = getParentBlockByType(row, RTETableBlock);
-    const allRows = getAllTableRows(table);
-    const currentRowIndex = allRows.indexOf(row);
-    const { colSpan, rowSpan } = getCellSpan(target);
-    const cellColumnPosition = getActualColumnPosition(target, allRows);
-    // When rowSpan=1, we need to insert a new row and both cells have rowSpan=1
-    // When rowSpan>1, we split the existing rowSpan
-    const topRowSpan = Math.ceil(rowSpan / 2);
-    const bottomRowSpan = Math.max(1, rowSpan - topRowSpan);
-    const needsNewRow = rowSpan === 1;
-    // Update original cell's rowSpan (top cell)
-    setSpanAttributes(target, colSpan, topRowSpan, table);
-    // Determine where the bottom cell should be inserted
-    const bottomCellRowIndex = currentRowIndex + topRowSpan;
-    // Create the bottom cell with the same col span and type as the original
-    const bottomCell = createNewCell(target.type);
-    setSpanAttributes(bottomCell, colSpan, bottomRowSpan, table);
-    if (needsNewRow) {
-      // Need to create a new row for the bottom cell
-      const newRow = this.createNewRowWithCell(section, bottomCell);
-      // Find the correct position in the section to insert the new row
-      const rowIndexInSection = section.children.indexOf(row);
-      section.apply(new InsertChildrenAfterAction(section.children[rowIndexInSection], newRow));
-      // Update allRows
-      allRows.splice(bottomCellRowIndex, 0, newRow);
-      // Update all cells from all previous rows that span through the insertion point
-      // (except the split cell itself)
-      this.updateCellsSpanningThroughInsertionPoint(allRows, bottomCellRowIndex, target, table);
-    }
-    else {
-      // Row exists - insert the bottom cell at the correct position
-      const targetRow = allRows[bottomCellRowIndex];
-      const insertIndex = this.findInsertPosition(targetRow, cellColumnPosition, allRows, bottomCellRowIndex);
-      targetRow.children.splice(insertIndex, 0, bottomCell);
-      bottomCell.parent = targetRow;
-    }
-  }
-  /**
-   * 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.
-   */
-  findInsertPosition(targetRow, targetColumnPosition, allRows, rowIndex) {
-    // Calculate columns occupied by cells from previous rows extending into this row
-    let columnsOccupiedByPreviousRows = 0;
-    for (let r = 0; r < rowIndex; r++) {
-      const prevRow = allRows[r];
-      for (const prevCell of prevRow.children) {
-        const { colSpan, rowSpan } = getCellSpan(prevCell);
-        // Check if this cell extends into the target row
-        if (r + rowSpan > rowIndex) {
-          const prevCellColumnPosition = getActualColumnPosition(prevCell, allRows);
-          if (prevCellColumnPosition < targetColumnPosition) {
-            columnsOccupiedByPreviousRows += colSpan;
-          }
-        }
-      }
-    }
-    // Find the insertion position in the target row
-    let currentColumn = columnsOccupiedByPreviousRows;
-    for (let i = 0; i < targetRow.children.length; i++) {
-      if (currentColumn >= targetColumnPosition) {
-        return i;
-      }
-      const cell = targetRow.children[i];
-      const { colSpan } = getCellSpan(cell);
-      currentColumn += colSpan;
-    }
-    return targetRow.children.length;
-  }
-  /**
-   * 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.
-   */
-  createNewRowWithCell(section, bottomCell) {
-    const rowTemplate = {
-      id: generateUUID(),
-      type: 'table-row',
-      children: [],
-    };
-    const newRow = RTETableRowBlock.from(rowTemplate);
-    newRow.parent = section;
-    // Add the bottom cell to the row
-    newRow.children.push(bottomCell);
-    bottomCell.parent = newRow;
-    return newRow;
-  }
-  /**
-   * 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.
-   */
-  updateCellsSpanningThroughInsertionPoint(allRows, insertionRowIndex, splitCell, table) {
-    // Check all rows before the insertion point (not including the inserted row itself)
-    for (let r = 0; r < insertionRowIndex; r++) {
-      const row = allRows[r];
-      for (const cell of row.children) {
-        // Skip the cell that was split - it already has the correct rowSpan
-        if (cell === splitCell) {
-          continue;
-        }
-        const { colSpan, rowSpan } = getCellSpan(cell);
-        // Calculate where this cell ends
-        const cellRowEnd = r + rowSpan;
-        // If this cell extends to or past where we inserted the row,
-        // it needs to span over the new row too
-        if (cellRowEnd >= insertionRowIndex) {
-          setSpanAttributes(cell, colSpan, rowSpan + 1, table);
-        }
-      }
-    }
-  }
-}

package/dist/collection/components/vega-rich-text-editor/extensions/table/action-handler-strategies/split-cell-vertically-strategy.js

@@ -1,80 +0,0 @@
-import { RTETableBlock } from '../dto/table-block';
-import { InsertChildrenAfterAction } from '../../../dto/actions/insert-children-after-block';
-import { getCellSpan, getParentBlockByType, setSpanAttributes, getAllTableRows, getActualColumnPosition, createNewCell, } from '../utils/utils';
-import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
-/**
- * Strategy to handle vertical split of a table cell (splits left/right).
- */
-export class SplitCellVerticallyStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(_action, target) {
-    const row = target.parent;
-    const table = getParentBlockByType(row, RTETableBlock);
-    const allRows = getAllTableRows(table);
-    const currentRowIndex = allRows.indexOf(row);
-    const { colSpan, rowSpan } = getCellSpan(target);
-    // Get the actual column position of the cell being split
-    const cellColumnStart = getActualColumnPosition(target, allRows);
-    const cellColumnEnd = cellColumnStart + colSpan - 1;
-    // Calculate new column spans (split the column span)
-    const leftColSpan = Math.ceil(colSpan / 2);
-    const rightColSpan = Math.floor(colSpan / 2);
-    // Update original cell's column spans (left cell)
-    setSpanAttributes(target, leftColSpan, rowSpan, table);
-    // Create new cell (right cell) with same type as original
-    const newCell = createNewCell(target.type);
-    setSpanAttributes(newCell, rightColSpan, rowSpan, table);
-    // Insert new cell after the original in the same row
-    row.apply(new InsertChildrenAfterAction(target, newCell));
-    // Only when splitting a cell with colSpan=1 do we add a new column to the table.
-    // When colSpan>1, we're just redistributing existing columns.
-    // For example:
-    //   colSpan=1: split into 1+1 → adds 1 new column
-    //   colSpan=2: split into 1+1 → just redistributes 2 existing columns
-    //   colSpan=3: split into 2+1 → just redistributes 3 existing columns
-    const newColumnsAdded = colSpan === 1 ? 1 : 0;
-    if (newColumnsAdded > 0) {
-      this.updateOtherRowsCells(allRows, currentRowIndex, cellColumnStart, cellColumnEnd, rowSpan, newColumnsAdded, table);
-    }
-  }
-  /**
-   * 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.
-   */
-  updateOtherRowsCells(allRows, splitRowIndex, splitColumnStart, splitColumnEnd, splitCellRowSpan, newColumnsAdded, table) {
-    // Iterate through all rows
-    for (let rowIndex = 0; rowIndex < allRows.length; rowIndex++) {
-      const currentRow = allRows[rowIndex];
-      // Skip rows that are spanned by the split cell itself
-      if (rowIndex >= splitRowIndex && rowIndex < splitRowIndex + splitCellRowSpan) {
-        continue;
-      }
-      // Check each cell in the current row
-      for (const cell of currentRow.children) {
-        const cellColumnStart = getActualColumnPosition(cell, allRows);
-        const { colSpan, rowSpan } = getCellSpan(cell);
-        const cellColumnEnd = cellColumnStart + colSpan - 1;
-        // Check if this cell spans across the columns where the split happened
-        // A cell needs updating if its column range overlaps with the split cell's column range
-        const overlaps = cellColumnEnd >= splitColumnStart && cellColumnStart <= splitColumnEnd;
-        if (overlaps) {
-          // Increase this cell's colSpan by the number of new columns added
-          setSpanAttributes(cell, colSpan + newColumnsAdded, rowSpan, table);
-          break; // No need to check other cells in this row
-        }
-      }
-    }
-  }
-}

package/dist/collection/components/vega-rich-text-editor/extensions/table/action-handler-strategies/table-column-strategy.abstract.js

@@ -1,19 +0,0 @@
-import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
-/**
- * Abstract base strategy for handling table column operations.
- * Provides common functionality for all column-related strategies.
- */
-export class TableColumnStrategy extends ActionHandleStrategy {
-  /**
-   * 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.
-   */
-  getBoundaryCellIndexOfRow(cellRange) {
-    const firstCell = cellRange[0];
-    const lastCell = cellRange[cellRange.length - 1];
-    return [firstCell.parent.children.indexOf(firstCell), lastCell.parent.children.indexOf(lastCell)];
-  }
-}

package/dist/collection/components/vega-rich-text-editor/extensions/table/action-handler-strategies/toggle-header-row-strategy.js

@@ -1,133 +0,0 @@
-import { generateUUID } from '../../../../../utils/misc';
-import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
-import { AppendChildrenAction } from '../../../dto/actions/append-child-nodes-action';
-import { InsertChildrenAfterAction } from '../../../dto/actions/insert-children-after-block';
-import { InsertChildrenBeforeAction } from '../../../dto/actions/insert-children-before-block';
-import { RemoveChildrenAction } from '../../../dto/actions/remove-child-action';
-import { UpdateCursorPositionAction } from '../../../dto/actions/update-cursor-position-action';
-import { RTETableBodyBlock } from '../dto/table-body-block';
-import { RTETableCellBlock } from '../dto/table-cell-block';
-import { RTETableHeadBlock } from '../dto/table-head-block';
-import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
-/**
- * Strategy class for handling converting selected rows to header rows or reverting them back to normal rows.
- */
-export class ToggleHeaderRowStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    const { selectedRows } = action;
-    const headerRows = [];
-    const bodyRows = [];
-    for (const row of selectedRows) {
-      if (row.parent instanceof RTETableBodyBlock) {
-        bodyRows.push(row);
-      }
-      else {
-        headerRows.push(row);
-      }
-    }
-    if (bodyRows.length > 0) {
-      this.convertToHeaderRows(bodyRows, target);
-    }
-    else {
-      this.revertToBodyRows(headerRows, target);
-    }
-    const root = this.getRootContent(target);
-    if (root) {
-      const focusNode = selectedRows[0].getFirstNode();
-      focusNode && root.apply(new UpdateCursorPositionAction(focusNode, 0));
-    }
-  }
-  /**
-   * Converts normal rows to header rows.
-   *
-   * @param {RTETableRowBlock[]} rows - The table row blocks to convert.
-   * @param {RTETableBlock} table - The table block containing the rows.
-   */
-  convertToHeaderRows(rows, table) {
-    let tableHead = table.children.find((block) => block instanceof RTETableHeadBlock);
-    const tableBody = rows[0].parent;
-    if (!tableHead) {
-      tableHead = RTETableHeadBlock.from({
-        id: generateUUID(),
-        type: 'table-head',
-        children: [],
-      });
-      table.apply(new InsertChildrenBeforeAction(tableBody, tableHead));
-    }
-    const endIndex = tableBody.children.indexOf(rows[rows.length - 1]);
-    const shouldConvertRows = tableBody.children.slice(0, endIndex + 1);
-    for (let i = 0; i < shouldConvertRows.length; i++) {
-      const rowBlock = shouldConvertRows[i];
-      rowBlock.children = rowBlock.children.map((cell) => this.convertTdToTh(cell));
-      tableBody.apply(new RemoveChildrenAction(rowBlock));
-    }
-    tableHead.apply(new AppendChildrenAction(shouldConvertRows));
-  }
-  /**
-   * 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.
-   */
-  revertToBodyRows(rows, table) {
-    let tableBody = table.children.find((block) => block instanceof RTETableBodyBlock);
-    const tableHead = rows[0].parent;
-    if (!tableBody) {
-      tableBody = RTETableBodyBlock.from({
-        id: generateUUID(),
-        type: 'table-body',
-        children: [],
-      });
-      table.apply(new InsertChildrenAfterAction(tableHead, tableBody));
-    }
-    const firstBodyRow = tableBody.children[0];
-    const startIndex = tableHead.children.indexOf(rows[0]);
-    const shouldConvertRows = tableHead.children.slice(startIndex);
-    for (let i = 0; i < shouldConvertRows.length; i++) {
-      const rowBlock = shouldConvertRows[i];
-      tableHead.apply(new RemoveChildrenAction(rowBlock));
-      rowBlock.children = this.convertThToTd(rowBlock, firstBodyRow);
-      if (firstBodyRow) {
-        tableBody.apply(new InsertChildrenBeforeAction(firstBodyRow, rowBlock));
-      }
-    }
-    if (!firstBodyRow) {
-      tableBody.apply(new AppendChildrenAction(shouldConvertRows));
-    }
-  }
-  /**
-   * 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.
-   */
-  convertTdToTh(cell) {
-    if (cell instanceof RTETableHeadCellBlock) {
-      return cell;
-    }
-    const headCell = RTETableHeadCellBlock.from(cell.toJSON());
-    headCell.parent = cell.parent;
-    return headCell;
-  }
-  /**
-   * 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.
-   */
-  convertThToTd(row, referenceRow) {
-    return row.children.map((cell, index) => {
-      let bodyCell = cell;
-      if (!referenceRow || referenceRow.children[index].type !== cell.type) {
-        const cellJSON = cell.toJSON();
-        bodyCell = RTETableCellBlock.from(cellJSON);
-      }
-      bodyCell.parent = row;
-      return bodyCell;
-    });
-  }
-}

package/dist/collection/components/vega-rich-text-editor/extensions/table/action-handler-strategies/toggle-header-table-column-strategy.js

@@ -1,99 +0,0 @@
-import { RTETableBlock } from '../dto/table-block';
-import { RTETableCellBlock } from '../dto/table-cell-block';
-import { RTETableBodyBlock } from '../dto/table-body-block';
-import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
-import { InsertChildrenBeforeAction } from '../../../dto/actions/insert-children-before-block';
-import { RemoveChildrenAction } from '../../../dto/actions/remove-child-action';
-import { TableColumnStrategy } from './table-column-strategy.abstract';
-import { getAllTableRows, getParentBlockByType } from '../utils/utils';
-import { UpdateCursorPositionAction } from '../../../dto/actions/update-cursor-position-action';
-/**
- * Strategy to handle the toggle of header state of a table column.
- */
-export class ToggleHeaderTableColumnStrategy extends TableColumnStrategy {
-  /**
-   * 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) {
-    if (selectedCellRange.length === 0) {
-      return false;
-    }
-    const endSelectedCell = selectedCellRange[selectedCellRange.length - 1];
-    const endSelectedCellIndex = endSelectedCell.parent.children.findIndex((child) => child === endSelectedCell);
-    const table = getParentBlockByType(endSelectedCell, RTETableBlock);
-    if (table) {
-      const allTableRows = getAllTableRows(table);
-      return allTableRows.every((row) => {
-        const cell = row.children[endSelectedCellIndex];
-        return cell instanceof RTETableHeadCellBlock;
-      });
-    }
-    return false;
-  }
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    var _a;
-    const headerOn = action.headerOn;
-    const [startCellIndex, endCellIndex] = this.getBoundaryCellIndexOfRow(action.tableCellHeaderRange);
-    const allTableBodyRows = ((_a = target.children.find((body) => body instanceof RTETableBodyBlock)) === null || _a === void 0 ? void 0 : _a.children) || [];
-    allTableBodyRows.forEach((row) => {
-      const firstTableCellIndex = row.children.findIndex((cell) => !(cell instanceof RTETableHeadCellBlock));
-      if (headerOn) {
-        this.toggleCellsToHeader(firstTableCellIndex, endCellIndex, row);
-      }
-      else {
-        this.toggleHeaderCellsToCells(firstTableCellIndex, row, startCellIndex);
-      }
-    });
-    const root = this.getRootContent(target);
-    if (root && action.tableCellHeaderRange[0].parent) {
-      const focusNode = action.tableCellHeaderRange[0].parent.getFirstNode();
-      focusNode && root.apply(new UpdateCursorPositionAction(focusNode, 0));
-    }
-  }
-  /**
-   * 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.
-   */
-  toggleHeaderCellsToCells(firstTableCellIndex, row, startCellIndex) {
-    const lastTableHeaderCellIndex = firstTableCellIndex >= 0 ? firstTableCellIndex - 1 : row.children.length - 1;
-    for (let cellIndex = startCellIndex; cellIndex <= lastTableHeaderCellIndex; cellIndex++) {
-      const cellToToggle = row.children[cellIndex];
-      const newCell = RTETableCellBlock.from(cellToToggle.toJSON());
-      this.replaceCellInRow(row, cellToToggle, newCell);
-    }
-  }
-  /**
-   * 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.
-   */
-  toggleCellsToHeader(firstTableCellIndex, endCellIndex, row) {
-    for (let tableCellIndex = firstTableCellIndex; tableCellIndex <= endCellIndex; tableCellIndex++) {
-      const cellToToggle = row.children[tableCellIndex];
-      const newHeaderCell = RTETableHeadCellBlock.from(cellToToggle.toJSON());
-      this.replaceCellInRow(row, cellToToggle, newHeaderCell);
-    }
-  }
-  /**
-   * 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.
-   */
-  replaceCellInRow(row, oldCell, newCell) {
-    row.apply(new InsertChildrenBeforeAction(oldCell, newCell));
-    row.apply(new RemoveChildrenAction(oldCell));
-  }
-}

package/dist/collection/components/vega-rich-text-editor/extensions/table/action-handler-strategies/update-table-cell-properties-strategy.js

@@ -1,24 +0,0 @@
-import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
-/**
- * Update table cell properties action handler strategy
- */
-export class UpdateTableCellPropertiesStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    const annotation = action.toAnnotation();
-    const tableCellRef = this.getDOMByEntity(target);
-    if (tableCellRef) {
-      const { width, height, borderStr, padding, textAlign, verticalAlign } = annotation;
-      const backgroundColor = annotation.renderStyle().backgroundColor || '';
-      tableCellRef.style.backgroundColor = backgroundColor;
-      tableCellRef.style.border = borderStr;
-      tableCellRef.style.width = width;
-      tableCellRef.style.height = height;
-      tableCellRef.style.padding = padding;
-      tableCellRef.style.textAlign = textAlign;
-      tableCellRef.style.verticalAlign = verticalAlign;
-    }
-  }
-}

package/dist/collection/components/vega-rich-text-editor/extensions/table/action-handler-strategies/update-table-properties-strategy.js

@@ -1,29 +0,0 @@
-import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
-/**
- * Update table properties action handler strategy
- */
-export class UpdateTablePropertiesStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    const annotation = action.toAnnotation();
-    const tableRef = this.getDOMByEntity(target);
-    if (tableRef) {
-      // Update the table styles directly on the DOM element if possible to avoid the component re-render
-      const tableContainer = tableRef.closest('.v-rte--extension-table-container');
-      const { backgroundColorAnnotation, width, height } = annotation;
-      tableRef.style.backgroundColor = backgroundColorAnnotation.renderStyle().color;
-      tableRef.style.border = annotation.borderStr;
-      tableRef.style.width = width;
-      tableRef.style.height = height;
-      const margin = annotation.renderAlignmentStyle().margin;
-      tableRef.style.margin = margin;
-      if (tableContainer) {
-        tableContainer.style.width = width;
-        tableContainer.style.height = height;
-        tableContainer.style.margin = margin;
-      }
-    }
-  }
-}

package/dist/collection/components/vega-rich-text-editor/extensions/table/actions/delete-table-block-action.js

@@ -1,13 +0,0 @@
-import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
-export const DELETE_TABLE_BLOCK = 'DELETE_TABLE_BLOCK';
-/**
- * Action to delete a table block
- */
-export class DeleteTableBlockAction extends ModifyContentAction {
-  constructor(target) {
-    super();
-    this.isFlushable = true;
-    this.type = DELETE_TABLE_BLOCK;
-    this.tableBlock = target;
-  }
-}

package/dist/collection/components/vega-rich-text-editor/extensions/table/actions/delete-table-column-action.js

@@ -1,13 +0,0 @@
-import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
-export const DELETE_TABLE_COLUMN = 'DELETE_TABLE_COLUMN';
-/**
- * Action to delete a table column
- */
-export class DeleteTableColumnAction extends ModifyContentAction {
-  constructor(target) {
-    super();
-    this.isFlushable = true;
-    this.type = DELETE_TABLE_COLUMN;
-    this.tableCellDeleteRange = target;
-  }
-}

package/dist/collection/components/vega-rich-text-editor/extensions/table/actions/delete-table-row-action.js

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

package/dist/collection/components/vega-rich-text-editor/extensions/table/actions/insert-table-block-action.js

@@ -1,13 +0,0 @@
-import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
-export const INSERT_TABLE_BLOCK = 'INSERT_TABLE_BLOCK';
-/**
- * Action to insert a table block into the rich text editor.
- */
-export class InsertTableBlockAction extends ModifyContentAction {
-  constructor(rowCount, columnCount) {
-    super();
-    this.type = INSERT_TABLE_BLOCK;
-    this.rowCount = rowCount;
-    this.columnCount = columnCount;
-  }
-}

package/dist/collection/components/vega-rich-text-editor/extensions/table/actions/insert-table-column-action.js

@@ -1,19 +0,0 @@
-import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
-export const INSERT_TABLE_COLUMN = 'INSERT_TABLE_COLUMN';
-export var InsertTableColumnDirection;
-(function (InsertTableColumnDirection) {
-  InsertTableColumnDirection["LEFT"] = "LEFT";
-  InsertTableColumnDirection["RIGHT"] = "RIGHT";
-})(InsertTableColumnDirection || (InsertTableColumnDirection = {}));
-/**
- * Action to insert a table column into the RTETable.
- */
-export class InsertTableColumnAction extends ModifyContentAction {
-  constructor(insertDirection, tableCellInsertRange) {
-    super();
-    this.isFlushable = true;
-    this.type = INSERT_TABLE_COLUMN;
-    this.tableCellInsertRange = tableCellInsertRange;
-    this.insertDirection = insertDirection;
-  }
-}

package/dist/collection/components/vega-rich-text-editor/extensions/table/actions/insert-table-row-action.js

@@ -1,26 +0,0 @@
-import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
-export const INSERT_TABLE_ROW = 'INSERT_TABLE_ROW';
-export var InsertTableRowDirection;
-(function (InsertTableRowDirection) {
-  InsertTableRowDirection["ABOVE"] = "ABOVE";
-  InsertTableRowDirection["BELOW"] = "BELOW";
-})(InsertTableRowDirection || (InsertTableRowDirection = {}));
-/**
- * Action class for inserting a new row into a table within the rich text editor.
- */
-export class InsertTableRowAction extends ModifyContentAction {
-  /**
-   * 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, selectedRows = []) {
-    super();
-    this.isFlushable = true;
-    this.type = INSERT_TABLE_ROW;
-    this.selectedRows = [];
-    this.insertDirection = insertDirection;
-    this.selectedRows = selectedRows;
-  }
-}

package/dist/collection/components/vega-rich-text-editor/extensions/table/actions/merge-cells-action.js

@@ -1,17 +0,0 @@
-import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
-export const MERGE_CELLS = 'MERGE_CELLS';
-/**
- * Action to merge cells into the RTETable.
- */
-export class MergeCellsAction extends ModifyContentAction {
-  constructor(targetCell, mergeCells, colSpan, rowSpan, direction) {
-    super();
-    this.type = MERGE_CELLS;
-    this.isFlushable = true;
-    this.targetCell = targetCell;
-    this.mergeCells = mergeCells;
-    this.colSpan = colSpan;
-    this.rowSpan = rowSpan;
-    this.direction = direction;
-  }
-}