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

package/dist/collection/components/vega-input-select/vega-input-select.js

@@ -12,6 +12,7 @@ import { VegaInputSelectRenderer } from './slimmers/renderers/vega-input-select-
 import { InjectVegaGlobalSlimmer, InjectVegaSlimmer, methodPlaceholder, } from 'vega-slimmer/core';
 import { VegaInputSelectDropdownController } from './slimmers/controllers/vega-input-select-dropdown-controller';
 import { VegaInputSelectValueController } from './slimmers/controllers/vega-input-select-value-controller';
+import { VegaInputSelectItemController } from './slimmers/controllers/vega-input-select-item-controller';
 import { VegaInputSelectDropdownRenderer } from './slimmers/renderers/vega-input-select-dropdown-renderer';
 import { FormFieldControllerSlimmer } from '../../helpers/slimmers/form-field-controller-slimmer';
 import { PageResizeObserverSlimmer } from '../../helpers/slimmers/page-resize-observer-slimmer';
@@ -40,6 +41,7 @@ export class VegaInputSelect {
     this.vegaInputSelectValueController = new VegaInputSelectValueController();
     this.vegaInputSelectDropdownRenderer = new VegaInputSelectDropdownRenderer();
     this.vegaInputSelectItemsSlotController = new VegaInputSelectItemsSlotController();
+    this.vegaInputSelectItemController = new VegaInputSelectItemController();
     this.formFieldControllerSlimmer = new FormFieldControllerSlimmer({
       propertyRules: [
         {
@@ -98,9 +100,13 @@ export class VegaInputSelect {
     this.required = false;
     /**
      * Allows customization of the text displayed within the
-     *    select field when multiple items are selected.
+     *    select field when single or multiple items are selected.
      *    The default format for the selected label is
-     *    `${number of selected items} Selected`.
+     *    `${number of selected items} Selected` for multiple mode only.
+     *
+     *	To enable all modes, use the `SelectedLabelTypeForAllModes` type.
+     * 		For single mode, the default format is the `displayName` of the selected item if not set
+     * 		For multiple mode, the default format is `${number of selected items} Selected` if not set
      *
      * @vegaVersion 1.35.0
      */
@@ -187,6 +193,9 @@ export class VegaInputSelect {
      */
     this.size = 'default';
   }
+  watchSelectType() {
+    methodPlaceholder();
+  }
   watchSource() {
     methodPlaceholder();
   }
@@ -313,12 +322,16 @@ export class VegaInputSelect {
       "type": "unknown",
       "mutable": false,
       "complexType": {
-        "original": "SelectedLabelType",
-        "resolved": "(value: string[]) => string",
+        "original": "SelectedLabelType | SelectedLabelTypeForAllModes",
+        "resolved": "((value: string[]) => string) | ({ single?: (value: string, selectedItem?: SelectSourceItem) => string; multiple?: (value: string[], selectedItem?: SelectSourceItem[]) => string; })",
         "references": {
           "SelectedLabelType": {
             "location": "import",
             "path": "./types"
+          },
+          "SelectedLabelTypeForAllModes": {
+            "location": "import",
+            "path": "./types"
           }
         }
       },
@@ -329,9 +342,9 @@ export class VegaInputSelect {
             "name": "vegaVersion",
             "text": "1.35.0"
           }],
-        "text": "Allows customization of the text displayed within the\n   select field when multiple items are selected.\n   The default format for the selected label is\n   `${number of selected items} Selected`."
+        "text": "Allows customization of the text displayed within the\n   select field when single or multiple items are selected.\n   The default format for the selected label is\n   `${number of selected items} Selected` for multiple mode only.\n\nTo enable all modes, use the `SelectedLabelTypeForAllModes` type.\n\t\tFor single mode, the default format is the `displayName` of the selected item if not set\n\t\tFor multiple mode, the default format is `${number of selected items} Selected` if not set"
       },
-      "defaultValue": "(value: string[]) => `${value.length} Selected`"
+      "defaultValue": "(value: string[]) =>\n\t\t`${value.length} Selected`"
     },
     "selectType": {
       "type": "string",
@@ -642,7 +655,8 @@ export class VegaInputSelect {
   static get states() { return {
     "isDropdownShow": {},
     "currentBreakpoint": {},
-    "isLazyLoading": {}
+    "isLazyLoading": {},
+    "selectedItem": {}
   }; }
   static get events() { return [{
       "method": "vegaChange",
@@ -937,6 +951,9 @@ export class VegaInputSelect {
   }; }
   static get elementRef() { return "host"; }
   static get watchers() { return [{
+      "propName": "selectType",
+      "methodName": "watchSelectType"
+    }, {
       "propName": "source",
       "methodName": "watchSource"
     }, {
@@ -977,6 +994,9 @@ __decorate([
 __decorate([
   InjectVegaSlimmer()
 ], VegaInputSelect.prototype, "vegaInputSelectItemsSlotController", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaInputSelect.prototype, "vegaInputSelectItemController", void 0);
 __decorate([
   InjectVegaSlimmer()
 ], VegaInputSelect.prototype, "formFieldControllerSlimmer", void 0);

package/dist/collection/components/vega-popover/slimmers/controllers/vega-popover-appender-controller.js

@@ -48,6 +48,7 @@ export class VegaPopoverAppenderController extends ElementAppenderSlimmer {
   }
   /**
    * Register a remote method to update the target element of the popover.
+   * TODO: refactor to using Change Manager
    */
   registerRemoteMethod() {
     remoteInvocationRegistry.register(domNodeSubjectFactory.getSubject(this.host, VegaInternalPopoverUpdateTarget), (target) => {

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/annotations/plain-text-annotation.js

@@ -37,6 +37,6 @@ export class PlainTextAnnotation extends NodeAnnotation {
    * @inheritDoc
    */
   toJSON() {
-    return { plainText: this.plainText };
+    return this.plainText ? { plainText: this.plainText } : undefined;
   }
 }

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/content-state.js

@@ -53,22 +53,27 @@ export class VegaRTEContent {
   /**
    * Create an empty content state
    *
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
    * @returns {VegaRTEContent} An empty content state
    */
-  static createEmptyContent() {
+  static createEmptyContent(options = { autoMatchFormat: true }) {
     return VegaRTEContent.fromJSON([
       {
         id: generateUUID(),
         type: 'paragraph',
+        annotations: {
+          internalWrapper: !options.autoMatchFormat,
+        },
         nodes: [
           {
             id: generateUUID(),
+            annotations: { plainText: !options.autoMatchFormat },
             type: 'text',
             text: '',
           },
         ],
       },
-    ]);
+    ], options);
   }
   /**
    * Converts HTML content to a VegaRTEContent instance.
@@ -141,8 +146,19 @@ export class VegaRTEContent {
     if (options) {
       LogUtility.warn(`The 'options' parameter in toHtml method is deprecated and will be removed in the future.`);
     }
+    if (this.isEmpty()) {
+      return '';
+    }
     return this.children.map((block) => block.toHtml()).join('');
   }
+  /**
+   * Checks if the content state is empty.
+   *
+   * @returns {boolean} True if the content state is empty, false otherwise.
+   */
+  isEmpty() {
+    return this.children.length === 0 || (this.children.length === 1 && !this.children[0].isNotEmpty());
+  }
   /**
    * Internal method to add the block item, remove the block item
    *

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