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

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

@@ -1,42 +0,0 @@
-import { ActionHandlerInterceptor, } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
-import { RTETextBlock } from '../../../dto/blocks/text-block';
-import { AppendChildrenAction } from '../../../dto/actions/append-child-nodes-action';
-import { RTETextNode } from '../../../dto/nodes/text-node';
-import { generateUUID } from '../../../../../utils/misc';
-/**
- * Interceptor to prevent removal of all children from a cell, ensuring at least one child remains.
- */
-export class PreventCellChildrenRemoveInterceptor extends ActionHandlerInterceptor {
-  /**
-   * 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, target) {
-    return action.entityToBeRemoved && target.children.length === 1;
-  }
-  /**
-   * 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, action, target) {
-    if (!(action.entityToBeRemoved instanceof RTETextBlock)) {
-      const newParagraph = RTETextBlock.from({
-        id: generateUUID(),
-        type: 'paragraph',
-        nodes: [{ id: generateUUID(), type: 'text', text: '' }],
-      });
-      target.children = [];
-      target.apply(new AppendChildrenAction([newParagraph]));
-      return;
-    }
-    action.entityToBeRemoved.apply(new AppendChildrenAction([
-      new RTETextNode(generateUUID(), '', action.entityToBeRemoved),
-    ]));
-  }
-}

package/dist/collection/components/vega-rich-text-editor/extensions/table/action-handler-interceptors/prevent-cell-content-delete-interceptor.js

@@ -1,26 +0,0 @@
-import { ActionHandlerInterceptor } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
-import { methodPlaceholder } from 'vega-slimmer/core';
-import { RTETableCellBlock } from '../dto/table-cell-block';
-/**
- * Interceptor to prevent deletion of a table cell if it is the cell with empty content.
- */
-export class PreventCellContentDeleteInterceptor extends ActionHandlerInterceptor {
-  /**
-   * 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, target) {
-    const cell = target.parent;
-    const isSingleCellChild = cell instanceof RTETableCellBlock && cell.children.length === 1;
-    return isSingleCellChild && action.startOffset === 0;
-  }
-  /**
-   * @inheritDoc
-   */
-  intercept() {
-    methodPlaceholder();
-  }
-}

package/dist/collection/components/vega-rich-text-editor/extensions/table/action-handler-interceptors/prevent-row-insert-interceptor.js

@@ -1,23 +0,0 @@
-import { ActionHandlerInterceptor } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
-import { methodPlaceholder } from 'vega-slimmer/core';
-import { RTETableCellBlock } from '../dto/table-cell-block';
-/**
- * Interceptor to prevent insertion of non-cell blocks into a table row.
- */
-export class PreventRowInsertInterceptor extends ActionHandlerInterceptor {
-  /**
-   * 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) {
-    return action.childrenToBeInserted.some((item) => !(item instanceof RTETableCellBlock));
-  }
-  /**
-   * @inheritDoc
-   */
-  intercept() {
-    methodPlaceholder();
-  }
-}

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

@@ -1,25 +0,0 @@
-import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
-import { RemoveChildrenAction } from '../../../dto/actions/remove-child-action';
-import { UpdateCursorPositionAction } from '../../../dto/actions/update-cursor-position-action';
-import { InsertChildrenAfterAction } from '../../../dto/actions/insert-children-after-block';
-/**
- * Strategy to handle the deletion of a table block from the parent.
- */
-export class DeleteTableBlockStrategy extends ActionHandleStrategy {
-  /**
-   * Deletes the specified table block and updates the cursor position.
-   *
-   * @param {DeleteTableBlockAction} action - The action containing the table block to delete.
-   */
-  handleAction(action) {
-    const tableBlock = action.tableBlock;
-    const parent = tableBlock.parent;
-    const root = super.getRootContent(tableBlock);
-    const newParagraph = super.createNewParagraph('');
-    parent.apply(new InsertChildrenAfterAction(tableBlock, newParagraph));
-    parent.apply(new RemoveChildrenAction(tableBlock));
-    if (root) {
-      root.apply(new UpdateCursorPositionAction(newParagraph.getLastNode()));
-    }
-  }
-}

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

@@ -1,57 +0,0 @@
-import { RemoveChildrenAction } from '../../../dto/actions/remove-child-action';
-import { getAllTableRows, getFirstNode } from '../utils/utils';
-import { UpdateCursorPositionAction } from '../../../dto/actions/update-cursor-position-action';
-import { TableColumnStrategy } from './table-column-strategy.abstract';
-/**
- * Strategy to handle the deletion of table column from the parent.
- */
-export class DeleteTableColumnStrategy extends TableColumnStrategy {
-  /**
-   * 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.
-   */
-  handleAction(action, target) {
-    const [startCellIndex, endCellIndex] = this.getBoundaryCellIndexOfRow(action.tableCellDeleteRange);
-    const allTableRows = getAllTableRows(target);
-    // Find the next focusable cell before deletion
-    const nextFocusableCell = this.findNextFocusableCell(action.tableCellDeleteRange, [startCellIndex, endCellIndex]);
-    allTableRows.forEach((row) => {
-      this.deleteCellsInRow(row, startCellIndex, endCellIndex);
-    });
-    const root = this.getRootContent(target);
-    const nextFocusNode = getFirstNode(nextFocusableCell);
-    if (root && nextFocusNode) {
-      root.apply(new UpdateCursorPositionAction(nextFocusNode));
-    }
-  }
-  /**
-   * 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.
-   */
-  findNextFocusableCell(tableCellBlockDeleteRange, indexRange) {
-    const cellAfterEndOfRange = tableCellBlockDeleteRange[tableCellBlockDeleteRange.length - 1].parent.children[indexRange[indexRange.length - 1] + 1];
-    const cellBeforeStartOfRange = tableCellBlockDeleteRange[0].parent.children[indexRange[0] - 1];
-    return cellAfterEndOfRange !== null && cellAfterEndOfRange !== void 0 ? cellAfterEndOfRange : cellBeforeStartOfRange;
-  }
-  /**
-   * 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.
-   */
-  deleteCellsInRow(row, startCellIndex, endCellIndex) {
-    const needDeleteCells = [];
-    for (let index = startCellIndex; index <= endCellIndex; index++) {
-      needDeleteCells.push(row.children[index]);
-    }
-    needDeleteCells.forEach((cell) => {
-      row.apply(new RemoveChildrenAction(cell));
-    });
-  }
-}

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

@@ -1,57 +0,0 @@
-import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
-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 { RTETableHeadBlock } from '../dto/table-head-block';
-/**
- * Strategy class for handling the deletion of table rows.
- */
-export class DeleteTableRowStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    const { rowsToBeRemoved } = action;
-    const futureFocusRow = this.getFutureFocusRow(rowsToBeRemoved[0], rowsToBeRemoved[rowsToBeRemoved.length - 1], target);
-    rowsToBeRemoved.forEach((row) => {
-      this.removeRow(row);
-    });
-    if (futureFocusRow) {
-      const root = this.getRootContent(target);
-      if (root) {
-        const focusNode = futureFocusRow.getLastNode();
-        root.apply(new UpdateCursorPositionAction(focusNode, focusNode.getRangeEndOffset()));
-      }
-    }
-  }
-  /**
-   * 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.
-   */
-  removeRow(rowToBeRemoved) {
-    rowToBeRemoved.parent.apply(new RemoveChildrenAction(rowToBeRemoved));
-  }
-  /**
-   * 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.
-   */
-  getFutureFocusRow(startRow, endRow, table) {
-    const allRows = table.children
-      .filter((item) => item instanceof RTETableHeadBlock || item instanceof RTETableBodyBlock)
-      .flatMap((block) => block.children);
-    const startIndex = allRows.indexOf(startRow);
-    const endIndex = allRows.indexOf(endRow);
-    if (allRows[startIndex - 1]) {
-      return allRows[startIndex - 1];
-    }
-    else if (allRows[endIndex + 1]) {
-      return allRows[endIndex + 1];
-    }
-  }
-}

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

@@ -1,54 +0,0 @@
-import { AppendChildrenAction } from '../../../dto/actions/append-child-nodes-action';
-import { InsertChildrenAfterAction } from '../../../dto/actions/insert-children-after-block';
-import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
-import { generateUUID } from '../../../../../utils/misc';
-import { VegaRTEContent } from '../../../dto/content-state';
-import { RTETableBlock } from '../dto/table-block';
-import { generateTableBody } from '../utils/utils';
-/**
- * Strategy to handle the insertion of a block into the rich text editor.
- */
-export class InsertTableBlockStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    const tableBlock = this.createTableBlock(action.rowCount, action.columnCount);
-    const emptyParagraph = super.createNewParagraph('');
-    const referenceBlock = this.getReferenceBlock(target);
-    if (referenceBlock) {
-      referenceBlock.parent.apply(new InsertChildrenAfterAction(referenceBlock, tableBlock, emptyParagraph));
-    }
-    else {
-      target.apply(new AppendChildrenAction([tableBlock, emptyParagraph]));
-    }
-    action.nextFocusNode = tableBlock.getFirstNode();
-  }
-  /**
-   * 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.
-   */
-  createTableBlock(row, column) {
-    const normalizedRowCount = Math.max(row, 1);
-    const normalizedColumnCount = Math.max(column, 1);
-    return RTETableBlock.from({
-      id: generateUUID(),
-      type: 'table-block',
-      children: [generateTableBody(normalizedRowCount, normalizedColumnCount)],
-    });
-  }
-  /**
-   * 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.
-   */
-  getReferenceBlock(currentTarget) {
-    if (!(currentTarget instanceof VegaRTEContent)) {
-      return currentTarget;
-    }
-  }
-}

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

@@ -1,42 +0,0 @@
-import { InsertChildrenAfterAction } from '../../../dto/actions/insert-children-after-block';
-import { RTETableCellBlock } from '../dto/table-cell-block';
-import { InsertTableColumnDirection } from '../actions/insert-table-column-action';
-import { InsertChildrenBeforeAction } from '../../../dto/actions/insert-children-before-block';
-import { getAllTableRows, getDefaultCellBlockTemplate } from '../utils/utils';
-import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
-import { TableColumnStrategy } from './table-column-strategy.abstract';
-/**
- * Strategy to handle the insertion of a table column into the RTETable.
- */
-export class InsertTableColumnStrategy extends TableColumnStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    const insertDirection = action.insertDirection;
-    const [startCellIndex, endCellIndex] = this.getBoundaryCellIndexOfRow(action.tableCellInsertRange);
-    const allTableRows = getAllTableRows(target);
-    allTableRows.forEach((row) => {
-      if (insertDirection === InsertTableColumnDirection.LEFT) {
-        const newCell = this.generateTableCell(row.children[startCellIndex]);
-        row.apply(new InsertChildrenBeforeAction(row.children[startCellIndex], newCell));
-      }
-      else {
-        const newCell = this.generateTableCell(row.children[endCellIndex + 1] || row.children[endCellIndex]);
-        row.apply(new InsertChildrenAfterAction(row.children[endCellIndex], newCell));
-      }
-    });
-  }
-  /**
-   * 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.
-   */
-  generateTableCell(originalCell) {
-    if (originalCell instanceof RTETableHeadCellBlock) {
-      return RTETableHeadCellBlock.from(getDefaultCellBlockTemplate(originalCell.type));
-    }
-    return RTETableCellBlock.from(getDefaultCellBlockTemplate(originalCell.type));
-  }
-}

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

@@ -1,163 +0,0 @@
-import { generateUUID } from '../../../../../utils/misc';
-import { cleanObject } from '../../../../../utils/object';
-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 { InsertTableRowDirection } from '../actions/insert-table-row-action';
-import { RTETableBodyBlock } from '../dto/table-body-block';
-import { RTETableHeadBlock } from '../dto/table-head-block';
-import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
-import { RTETableRowBlock } from '../dto/table-row-block';
-/**
- * Strategy class for handling the insertion of a new row into a table.
- */
-export class InsertTableRowStrategy extends ActionHandleStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    const { insertDirection, selectedRows } = action;
-    // The reference block will control where to insert the new row
-    const refBlock = insertDirection === InsertTableRowDirection.ABOVE
-      ? selectedRows[0]
-      : selectedRows[selectedRows.length - 1];
-    const refBlockIsHeaderRow = refBlock.parent instanceof RTETableHeadBlock;
-    // The refBlock is a head row and new row is also a head row or the refBlock is a body row and new row is also a body row
-    if (this.shouldInsertHeaderRow(refBlock, insertDirection) || !refBlockIsHeaderRow) {
-      const rowBlock = RTETableRowBlock.from({
-        id: generateUUID(),
-        type: 'table-row',
-        children: refBlock.children.map((item) => {
-          return this.getDefaultCellBlockTemplate(item.type, item.colSpan);
-        }),
-      });
-      if (insertDirection === InsertTableRowDirection.ABOVE) {
-        refBlock.parent.apply(new InsertChildrenBeforeAction(refBlock, rowBlock));
-      }
-      else {
-        refBlock.parent.apply(new InsertChildrenAfterAction(refBlock, rowBlock));
-      }
-    }
-    else {
-      // The refBlock is a head row and new row is a body row
-      let tableBody = target.children.find((block) => block instanceof RTETableBodyBlock);
-      const rowBlockJSON = {
-        id: generateUUID(),
-        type: 'table-row',
-        children: [],
-      };
-      if (!tableBody) {
-        rowBlockJSON.children = refBlock.children.map((item) => {
-          const { colSpan } = item;
-          return this.getDefaultCellBlockTemplate('table-cell', colSpan);
-        });
-        tableBody = RTETableBodyBlock.from({
-          id: generateUUID(),
-          type: 'table-body',
-          children: [],
-        });
-        tableBody.apply(new AppendChildrenAction([RTETableRowBlock.from(rowBlockJSON)]));
-        target.apply(new AppendChildrenAction([tableBody]));
-      }
-      else {
-        const firstBodyRow = tableBody.children[0];
-        const headCellLength = this.getHeadCellLength(firstBodyRow);
-        rowBlockJSON.children = this.createTableCells(refBlock, headCellLength);
-        tableBody.apply(new InsertChildrenBeforeAction(firstBodyRow, RTETableRowBlock.from(rowBlockJSON)));
-      }
-    }
-  }
-  /**
-   * 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.
-   */
-  shouldInsertHeaderRow(refBlock, direction) {
-    if (direction === InsertTableRowDirection.ABOVE) {
-      return refBlock.parent instanceof RTETableHeadBlock;
-    }
-    else {
-      const parentBlock = refBlock.parent;
-      return (parentBlock instanceof RTETableHeadBlock &&
-        parentBlock.children[parentBlock.children.length - 1] !== refBlock);
-    }
-  }
-  /**
-   * 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.
-   */
-  getDefaultCellBlockTemplate(cellType, colSpan, rowSpan = 1) {
-    const customAttribute = cleanObject({
-      colspan: colSpan > 1 ? colSpan.toString() : null,
-      rowspan: rowSpan > 1 ? rowSpan.toString() : null,
-    });
-    const id = generateUUID();
-    const cellBlock = {
-      id,
-      type: cellType,
-      children: [
-        {
-          id: `${id}-p`,
-          type: 'paragraph',
-          nodes: [
-            {
-              id: `${id}-p-t`,
-              type: 'text',
-              text: '',
-            },
-          ],
-        },
-      ],
-    };
-    if (Object.keys(customAttribute).length > 0) {
-      cellBlock.annotations = {
-        customAttribute,
-      };
-    }
-    return cellBlock;
-  }
-  /**
-   * 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.
-   */
-  getHeadCellLength(tableRow) {
-    let length = 0;
-    for (let i = 0; i < tableRow.children.length; i++) {
-      const cellBlock = tableRow.children[i];
-      if (cellBlock instanceof RTETableHeadCellBlock) {
-        length += cellBlock.colSpan;
-      }
-      else {
-        break;
-      }
-    }
-    return length;
-  }
-  /**
-   * 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.
-   */
-  createTableCells(refRow, headCellLength) {
-    const cells = [];
-    let currentHeadCellLength = 0;
-    for (const cell of refRow.children) {
-      const isHeadCell = currentHeadCellLength < headCellLength;
-      const cellType = isHeadCell ? 'table-head-cell' : 'table-cell';
-      cells.push(this.getDefaultCellBlockTemplate(cellType, cell.colSpan));
-      currentHeadCellLength += cell.colSpan;
-    }
-    return cells;
-  }
-}

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

@@ -1,120 +0,0 @@
-import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
-import { RemoveChildrenAction } from '../../../dto/actions/remove-child-action';
-import { getFirstNode, getCellSpan, buildTableGrid, setSpanAttributes } from '../utils/utils';
-import { UpdateCursorPositionAction } from '../../../dto/actions/update-cursor-position-action';
-import { MergeCellsOperationType } from '../setting-event-handlers/merge-cells-operation';
-/**
- * Strategy to handle the merging of table cells.
- */
-export class MergeCellsStrategy extends ActionHandleStrategy {
-  /**
-   * Handles the merge cells action.
-   *
-   * @param {MergeCellsAction} action - The action containing merge details.
-   * @param {RTETableBlock} target - The target table block.
-   */
-  handleAction(action, target) {
-    const { targetCell, mergeCells, colSpan, rowSpan, direction } = action;
-    this.mergeContentToTargetCell(targetCell, mergeCells);
-    setSpanAttributes(targetCell, colSpan, rowSpan, target);
-    this.deleteOtherSelectedCells(mergeCells, targetCell);
-    if (direction !== MergeCellsOperationType.MERGE_CELL_LEFT &&
-      direction !== MergeCellsOperationType.MERGE_CELL_RIGHT &&
-      rowSpan > 1) {
-      this.clearRowSpanIfUniformAcrossRow(targetCell, target, rowSpan);
-    }
-    const root = this.getRootContent(target);
-    const nextFocusNode = getFirstNode(targetCell);
-    if (root && nextFocusNode) {
-      root.apply(new UpdateCursorPositionAction(nextFocusNode));
-    }
-  }
-  /**
-   * Merge content from all selected cells to the target cell.
-   *
-   * @param {RTETableCellBlock | RTETableHeadCellBlock} targetCell - The target cell.
-   * @param {RTETableCellBlock[] | RTETableHeadCellBlock[]} selectedCells - All selected cells.
-   */
-  mergeContentToTargetCell(targetCell, selectedCells) {
-    const allChildren = selectedCells.flatMap((cell) => cell.children);
-    const valueCells = allChildren.filter((child) => child.isNotEmpty());
-    const allChildrenBlocks = valueCells.length > 0 ? valueCells : [allChildren[0]];
-    targetCell.children = allChildrenBlocks.map((childBlock) => childBlock.clone(targetCell));
-  }
-  /**
-   * 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).
-   */
-  deleteOtherSelectedCells(selectedCells, targetCell) {
-    selectedCells.forEach((cell) => {
-      if (cell !== targetCell) {
-        const row = cell.parent;
-        row.apply(new RemoveChildrenAction(cell));
-      }
-    });
-  }
-  /**
-   * 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.
-   */
-  clearRowSpanIfUniformAcrossRow(targetCell, table, targetCellRowSpan) {
-    const targetRow = targetCell.parent;
-    const allRows = targetRow.parent.children;
-    const grid = buildTableGrid(allRows);
-    const rowIndexes = [];
-    for (let r = 0; r < grid.length; r++) {
-      if (grid[r].includes(targetCell.id)) {
-        rowIndexes.push(r);
-      }
-    }
-    if (rowIndexes.length > 1) {
-      const windowStart = rowIndexes[0];
-      const windowEnd = windowStart + targetCellRowSpan - 1;
-      const uniformIds = new Set();
-      let minRowSpan = Number.POSITIVE_INFINITY;
-      for (let c = 0; c < grid[0].length; c++) {
-        let firstId = grid[windowStart][c];
-        let count = 1;
-        let isRowSpan = false;
-        for (let r = windowStart + 1; r <= windowEnd; r++) {
-          if (grid[r][c] === firstId) {
-            count++;
-            continue;
-          }
-          if (count > 1) {
-            isRowSpan = true;
-            minRowSpan = Math.min(minRowSpan, count);
-            uniformIds.add(firstId);
-          }
-          count = 1;
-          firstId = grid[r][c];
-        }
-        if (count < 2 && !isRowSpan) {
-          uniformIds.clear();
-          break;
-        }
-        if (count > 1) {
-          minRowSpan = Math.min(minRowSpan, count);
-          uniformIds.add(firstId);
-        }
-      }
-      if (uniformIds.size > 0) {
-        allRows.forEach((row) => {
-          row.children.forEach((cell) => {
-            if (uniformIds.has(cell.id)) {
-              const { rowSpan, colSpan } = getCellSpan(cell);
-              const reducedRowSpan = rowSpan - minRowSpan + 1;
-              setSpanAttributes(cell, colSpan, reducedRowSpan, table);
-            }
-          });
-        });
-      }
-    }
-  }
-}

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

@@ -1,22 +0,0 @@
-import { getAllTableRows } from '../utils/utils';
-import { TableColumnStrategy } from './table-column-strategy.abstract';
-/**
- * Strategy to handle the selection of a table column.
- */
-export class SelectTableColumnStrategy extends TableColumnStrategy {
-  /**
-   * @inheritDoc
-   */
-  handleAction(action, target) {
-    const [startCellIndex, endCellIndex] = this.getBoundaryCellIndexOfRow(action.tableCellSelectRange);
-    const allTableRows = getAllTableRows(target);
-    const allNeedSelectedCells = [];
-    allTableRows.forEach((row) => {
-      for (let cellIndex = startCellIndex; cellIndex <= endCellIndex; cellIndex++) {
-        const cellToSelect = row.children[cellIndex];
-        allNeedSelectedCells.push(cellToSelect);
-      }
-    });
-    action.selectCellCallback(allNeedSelectedCells);
-  }
-}