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

package/dist/collection/components/vega-rich-text-content/vega-rich-text-content.js

@@ -13,6 +13,8 @@ import { VegaRichTextContentStateController } from './slimmers/controllers/vega-
 import { findParent } from '../../utils/ui';
 import { waitForComponentDidRender } from '../../helpers/common';
 import { RTEExtensionStylesController } from './slimmers/controllers/vega-rich-text-content-extensions-styles-controller';
+import { DarkModeStateControllerSlimmer } from '../../helpers/slimmers/dark-mode-state-controller-slimmer';
+import { VegaInternalThemeManager } from '../../helpers/theme/internal-theme-manager';
 /**
  * @vegaVersion 2.34.0
  */
@@ -23,6 +25,7 @@ export class VegaRichTextContent {
     this.vegaRichTextContentRenderer = new VegaRichTextContentRenderer();
     this.vegaRichTextContentStateController = new VegaRichTextContentStateController();
     this.vegaRichTextContentExtensionsStylesController = new RTEExtensionStylesController();
+    this.darkModeStateControllerSlimmer = new DarkModeStateControllerSlimmer();
     /**
      * Specifies whether the rich text content is editable.
      *
@@ -33,6 +36,7 @@ export class VegaRichTextContent {
      * Holds the custom styles generated by extensions.
      */
     this.extensionStyles = '';
+    this.isInDarkMode = VegaInternalThemeManager.isDarkMode();
     /**
      * Defines the configuration for rich text content extensions.
      * It enables support for custom nodes, ensuring that extended content is rendered correctly.
@@ -122,7 +126,8 @@ export class VegaRichTextContent {
   static get states() { return {
     "placeholder": {},
     "contentEditable": {},
-    "extensionStyles": {}
+    "extensionStyles": {},
+    "isInDarkMode": {}
   }; }
   static get methods() { return {
     "vegaFocus": {
@@ -176,3 +181,6 @@ __decorate([
 __decorate([
   InjectVegaSlimmer()
 ], VegaRichTextContent.prototype, "vegaRichTextContentExtensionsStylesController", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaRichTextContent.prototype, "darkModeStateControllerSlimmer", void 0);

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/action-handle-strategy.abstract.js

@@ -1,6 +1,7 @@
 import RTEDTOClassManager from '../../../../helpers/rte-manager/dto-class-manager';
 import { LogUtility } from '../../../../utils/log';
 import { generateUUID } from '../../../../utils/misc';
+import stateEntityRenderingRegistry from '../../slimmers/controllers/state-entity-rendering-registry';
 import { CommonAnnotationTypeEnum } from '../annotations/common-annotation.abstract';
 import { CustomStyleAnnotation } from '../annotations/custom-style-annotation';
 /**
@@ -92,6 +93,15 @@ export class ActionHandleStrategy {
       return this.isCaretPositionAtTextBlockEnd(block, node, offset);
     }
   }
+  /**
+   * Get the registered DOM element by the RTE entity.
+   *
+   * @param {RTEBlock | RTENode} instance - The RTE block or node instance.
+   * @returns {Nullable<HTMLElement>} The registered DOM element.
+   */
+  getDOMByEntity(instance) {
+    return stateEntityRenderingRegistry.getDOMByEntity(instance);
+  }
   /**
    * Checks if the caret position is at the end of a specified RTETextNode.
    *

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
    *
@@ -234,7 +248,15 @@ export class RTEBlock {
     if (!(annotation instanceof LinkGroupAnnotation)) {
       this.annotationMap.set(annotation.type, annotation);
     }
-    typeof this.doAnnotationActionApply === 'function' && this.doAnnotationActionApply(action);
+    if (typeof this.doAnnotationActionApply === 'function') {
+      this.doAnnotationActionApply(action);
+    }
+    else {
+      const strategy = ActionHandleStrategyRegistry.get(action.constructor.name, this.constructor.name);
+      if (strategy) {
+        strategy.execute(action, this);
+      }
+    }
   }
   /**
    * clone annotations of the block

package/dist/collection/components/vega-rich-text-editor/dto/renderers/nodes/text-node-renderer.js

@@ -2,22 +2,12 @@ import { h } from '@stencil/core';
 import { RTENodeRenderer } from './node-renderer.abstract';
 import { NodeAnnotationTypeEnum } from '../../annotations/node-annotation.abstract';
 import { ZERO_WIDTH_SPACE } from '../../../constants/constant';
-import TextNodeElementRenderingRegistry from '../../../slimmers/controllers/text-node-rendering-registry';
 class RTETextNodeRenderer extends RTENodeRenderer {
   render(node) {
     const inlineHtmlAnnotation = node.getAnnotationByType(NodeAnnotationTypeEnum.INLINE_HTML);
     const textNodeDom = this.renderText(node);
     return inlineHtmlAnnotation ? this.renderWithWrapper(textNodeDom, inlineHtmlAnnotation) : textNodeDom;
   }
-  registerRef(ref, node) {
-    super.registerRef(ref, node);
-    if (ref) {
-      const textColorAnnotation = node.getAnnotationByType('TEXT_COLOR');
-      if (textColorAnnotation) {
-        TextNodeElementRenderingRegistry.register(ref, textColorAnnotation);
-      }
-    }
-  }
   renderWithWrapper(textNodeDom, inlineHtmlNode) {
     const { htmlTag: HtmlTag, customStyle, customAttribute, customClass, } = inlineHtmlNode;
     const attrs = Object.assign(Object.assign({}, customAttribute === null || customAttribute === void 0 ? void 0 : customAttribute.render()), { style: customStyle === null || customStyle === void 0 ? void 0 : customStyle.renderStyle(), class: customClass === null || customClass === void 0 ? void 0 : customClass.renderClass().join(' ') });

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,8 @@ 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';
+import htmlElementToAnnotationGenerator from '../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator';
 /**
  * Abstract class for Vega Rich Text Editor extensions.
  */
@@ -21,7 +23,7 @@ export class VegaRTEExtension {
    *
    * @param {string} nodeOrBlockClassName - The name of the node or block class.
    * @param {string} actionType - The type of the action.
-   * @param {ActionHandleStrategy<ModifyContentAction, RTENode | RTEBlock | VegaRTEContent>} strategy - The strategy to register.
+   * @param {ActionHandleStrategy<ModifyContentAction | AnnotationAction, RTENode | RTEBlock | VegaRTEContent>} strategy - The strategy to register.
    */
   static registerActionHandleStrategy(nodeOrBlockClassName, actionType, strategy) {
     ActionHandleStrategyRegistry.register(actionType, nodeOrBlockClassName, strategy);
@@ -44,6 +46,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.
@@ -144,4 +153,12 @@ export class VegaRTEExtension {
   getElementToNodeDTOClassStrategies() {
     return ElementToDTOClassStrategyManager.getElementToNodeStrategies();
   }
+  /**
+   * Register a custom annotation handler for HTML to DTO conversion.
+   *
+   * @param {AnnotationGeneratorStrategyAbstract} handler - The annotation handler to register.
+   */
+  registerAnnotationHandler(handler) {
+    htmlElementToAnnotationGenerator.registerHandler(handler);
+  }
 }

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,26 @@
+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

@@ -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));
+  }
+}