@heartlandone/vega 2.71.0 → 2.72.0-RTE-table-preview

package/dist/collection/components/vega-rich-text-editor/dto/blocks/block.abstract.js

@@ -128,7 +128,7 @@ export class RTEBlock {
    * Get annotation by type
    *
    * @typedef T generic type
-   * @param {keyof typeof BlockAnnotationTypeEnum} type - Annotation type
+   * @param {string} type - Annotation type
    * @returns {Nullable<T>} - Annotation
    */
   getAnnotationByType(type) {
@@ -151,6 +151,20 @@ export class RTEBlock {
       }
     }
   }
+  /**
+   * Get the first node of the block
+   *
+   * @returns {Nullable<RTENode>} The first RTENode or null if no children exist.
+   */
+  getFirstNode() {
+    if (!this.children || !this.children[0])
+      return null;
+    const firstItem = this.children[0];
+    if (firstItem instanceof RTEBlock) {
+      return firstItem.getFirstNode();
+    }
+    return firstItem;
+  }
   /**
    * Check if the block is a list item block
    *

package/dist/collection/components/vega-rich-text-editor/extensions/base-extension-renderer.js

@@ -24,9 +24,10 @@ export class VegaRTEExtensionRenderer extends VegaRTEBaseRenderer {
    * @returns {VegaRTERenderResult} - The rendered DOM element.
    */
   render(renderData, rteContext, createElement) {
+    var _a;
     const element = this.doRender(createElement, renderData, rteContext);
     this.fallbackRegisterRef(element, renderData);
-    this.appendChildren(element, renderData, rteContext, createElement);
+    this.appendChildren(((_a = element.childrenContainerGetter) === null || _a === void 0 ? void 0 : _a.call(element)) || element, renderData, rteContext, createElement);
     return element;
   }
   /**

package/dist/collection/components/vega-rich-text-editor/extensions/extension.abstract.js

@@ -5,6 +5,7 @@ import ElementToDTOClassStrategyManager from '../../../helpers/rte-manager/eleme
 import { ActionHandleStrategyRegistry } from '../dto/action-handle-strategies/action-handle-strategy-registry';
 import { VegaRTEExtensionRenderer } from './base-extension-renderer';
 import { ActionHandlerInterceptorRegistry } from '../dto/action-handle-strategies/action-handle-interceptor-registry';
+import { methodPlaceholder } from 'vega-slimmer/core';
 /**
  * Abstract class for Vega Rich Text Editor extensions.
  */
@@ -44,6 +45,13 @@ export class VegaRTEExtension {
   initialExtension(context) {
     this.extensionContext = context;
   }
+  /**
+   * Callback method invoked when the extension is destroyed.
+   * Override this method to perform any necessary cleanup.
+   */
+  destroyExtension() {
+    methodPlaceholder();
+  }
   /**
    * Collect custom styles for the extension renderers.
    * If custom nodes have special styles, override this method to provide the styles.

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

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

@@ -0,0 +1,25 @@
+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;
+    return cell instanceof RTETableCellBlock && cell.children.length === 1 && !target.isNotEmpty();
+  }
+  /**
+   * @inheritDoc
+   */
+  intercept() {
+    methodPlaceholder();
+  }
+}

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

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

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

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

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

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

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

@@ -0,0 +1,117 @@
+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 { InsertTableRowDirection } from '../actions/insert-table-row-action';
+import { RTETableBodyBlock } from '../dto/table-body-block';
+import { RTETableHeadBlock } from '../dto/table-head-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
+    let refBlock = insertDirection === InsertTableRowDirection.ABOVE
+      ? selectedRows[0]
+      : selectedRows[selectedRows.length - 1];
+    // The row need to be inserted is a header row
+    if (this.shouldInsertHeaderRow(refBlock, insertDirection)) {
+      const headerBlock = RTETableRowBlock.from({
+        id: generateUUID(),
+        type: 'table-row',
+        children: refBlock.children.map((item) => {
+          return this.getDefaultCellBlockTemplate(item.type);
+        }),
+      });
+      if (insertDirection === InsertTableRowDirection.ABOVE) {
+        refBlock.parent.apply(new InsertChildrenBeforeAction(refBlock, headerBlock));
+      }
+      else {
+        refBlock.parent.apply(new InsertChildrenAfterAction(refBlock, headerBlock));
+      }
+    }
+    else {
+      let direction = insertDirection;
+      let tableBody = target.children.find((block) => block instanceof RTETableBodyBlock);
+      // Should insert into body if reference block is in head row and body exists
+      if (refBlock.parent instanceof RTETableHeadBlock && tableBody) {
+        refBlock = tableBody.children[0];
+        direction = InsertTableRowDirection.ABOVE;
+      }
+      const refBlockIsHeaderRow = refBlock.parent instanceof RTETableHeadBlock;
+      const rowBlock = RTETableRowBlock.from({
+        id: generateUUID(),
+        type: 'table-row',
+        children: refBlock.children.map((item) => {
+          return this.getDefaultCellBlockTemplate(refBlockIsHeaderRow ? 'table-cell' : item.type);
+        }),
+      });
+      if (!tableBody) {
+        tableBody = RTETableBodyBlock.from({
+          id: generateUUID(),
+          type: 'table-body',
+          children: [],
+        });
+        tableBody.apply(new AppendChildrenAction([rowBlock]));
+        target.apply(new AppendChildrenAction([tableBody]));
+      }
+      else {
+        if (direction === InsertTableRowDirection.ABOVE) {
+          tableBody.apply(new InsertChildrenBeforeAction(refBlock, rowBlock));
+        }
+        else {
+          tableBody.apply(new InsertChildrenAfterAction(refBlock, rowBlock));
+        }
+      }
+    }
+  }
+  /**
+   * 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.
+   * @returns {VegaRTETableCellBlock | VegaRTETableHeadCellBlock} The default cell block template.
+   */
+  getDefaultCellBlockTemplate(cellType) {
+    const id = generateUUID();
+    return {
+      id,
+      type: cellType,
+      children: [
+        {
+          id: `${id}-p`,
+          type: 'paragraph',
+          nodes: [
+            {
+              id: `${id}-p-t`,
+              type: 'text',
+              text: '',
+            },
+          ],
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,22 @@
+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);
+  }
+}

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

@@ -0,0 +1,19 @@
+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)];
+  }
+}