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

package/dist/cjs/vega-rich-text-table-selection-widget.cjs.entry.js

@@ -1,184 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const index = require('./index-58ea899e.js');
-const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
-const componentUsageRuntimeMetrics = require('./component-usage-runtime-metrics-d10ace87.js');
-const component = require('./component-1e352960.js');
-const ui = require('./ui-9e181079.js');
-const keyboardManagerSlimmer = require('./keyboard-manager-slimmer-15e65357.js');
-require('./keyboard-manager-d8adb0ed.js');
-require('./type-guard-69d2cf01.js');
-require('./breakpoints-ebde4837.js');
-require('./ui-32e69595.js');
-require('./typography-4560e7f1.js');
-require('./translation-5f9f9c0c.js');
-require('./change-manager-a297e4d2.js');
-require('./static-subject-title-5829a298.js');
-require('./create-public-api-runtime-metrics-slimmer-e2e274e1.js');
-require('./dynamic-slimmer-f31fdfd7.js');
-
-var __decorate$2 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-class SelectionWidgetRenderer extends globalSlimmerRegistry.VegaSlimmer {
-  constructor() {
-    super(...arguments);
-    /**
-     * Handles the selection of the widget.
-     *
-     * @param {MouseEvent} e - The mouse event.
-     */
-    this.handleWidgetSelection = (e) => {
-      e.stopPropagation();
-      this.isSelected = true;
-    };
-    /**
-     * Handles clicks outside the widget to deselect it.
-     */
-    this.handleEditorContentClick = () => {
-      this.isSelected = false;
-    };
-    /**
-     * Registers the editor content click listener.
-     */
-    this.registerEditorContentClickListener = () => {
-      if (this.editorContentContainerRef) {
-        this.editorContentContainerRef.addEventListener('mousedown', this.handleEditorContentClick);
-      }
-    };
-    /**
-     * Un-registers the editor content click listener.
-     */
-    this.unRegisterEditorContentClickListener = () => {
-      if (this.editorContentContainerRef) {
-        this.editorContentContainerRef.removeEventListener('mousedown', this.handleEditorContentClick);
-      }
-    };
-  }
-  connectedCallback() {
-    this.editorContentContainerRef = ui.findParent(this.host, '.rich-text-editor-container');
-  }
-  disconnectedCallback() {
-    this.unRegisterEditorContentClickListener();
-  }
-  watchIsSelected(newValue) {
-    if (newValue) {
-      this.registerEditorContentClickListener();
-    }
-    else {
-      this.unRegisterEditorContentClickListener();
-    }
-  }
-  getWidgetHandleRef() {
-    return this.widgetHandleRef;
-  }
-  render() {
-    return (index.h("div", { class: ui.arrayToClassString(['v-rte-widget__selection', this.isSelected ? 'selected' : '']), contentEditable: false },
-      index.h("button", { class: "v-rte-widget__selection-handle", ref: (el) => (this.widgetHandleRef = el), onClick: this.handleWidgetSelection }),
-      index.h("div", { class: "v-rte-widget__selection-content" },
-        index.h("slot", null))));
-  }
-}
-__decorate$2([
-  globalSlimmerRegistry.MapToComponentField()
-], SelectionWidgetRenderer.prototype, "host", void 0);
-__decorate$2([
-  globalSlimmerRegistry.MapToComponentField({ writable: true })
-], SelectionWidgetRenderer.prototype, "isSelected", void 0);
-__decorate$2([
-  globalSlimmerRegistry.MapToComponentMethod('connectedCallback')
-], SelectionWidgetRenderer.prototype, "connectedCallback", null);
-__decorate$2([
-  globalSlimmerRegistry.MapToComponentMethod('disconnectedCallback')
-], SelectionWidgetRenderer.prototype, "disconnectedCallback", null);
-__decorate$2([
-  globalSlimmerRegistry.MapToComponentMethod('watchIsSelected')
-], SelectionWidgetRenderer.prototype, "watchIsSelected", null);
-
-var __decorate$1 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-/**
- * Keyboard controller for table selection widget
- */
-class SelectionWidgetKeyboardController extends keyboardManagerSlimmer.KeyboardManagerSlimmer {
-  constructor() {
-    super(() => [
-      {
-        keyCode: 'Backspace',
-        eventName: 'keydown',
-        activeElementInScope: [this.selectionWidgetRenderer.getWidgetHandleRef()],
-        callback: this.handleDeleteKeyDown,
-      },
-    ]);
-    /**
-     * Handles the delete key down event.
-     *
-     */
-    this.handleDeleteKeyDown = () => {
-      this.vegaRemove.emit();
-    };
-  }
-}
-__decorate$1([
-  globalSlimmerRegistry.MapToComponentField()
-], SelectionWidgetKeyboardController.prototype, "vegaRemove", void 0);
-__decorate$1([
-  globalSlimmerRegistry.MapToComponentField()
-], SelectionWidgetKeyboardController.prototype, "selectionWidgetRenderer", void 0);
-
-const vegaRichTextTableSelectionWidgetCss = ":host{display:block;position:relative;padding-top:19px}:host(:hover) .v-rte-widget__selection-content{outline:2px solid rgb(255, 200, 61)}:host(:hover) .v-rte-widget__selection-handle{display:revert;background:rgb(255, 200, 61)}.v-rte-widget__selection.selected .v-rte-widget__selection-content{outline:2px solid rgb(38, 42, 255)}.v-rte-widget__selection.selected .v-rte-widget__selection-handle{display:revert;background:rgb(38, 42, 255)}.v-rte-widget__selection-handle{border:none;outline:none;width:15px;height:15px;position:absolute;top:2px;left:-2px;padding:2px;box-sizing:border-box;display:none}.v-rte-widget__selection-handle:after{content:\"\";border:1px dashed rgb(255, 255, 255);width:auto;height:100%;display:block}";
-
-var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1; i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-const VegaRichTextTableSelectionWidget = class {
-  constructor(hostRef) {
-    index.registerInstance(this, hostRef);
-    this.vegaRemove = index.createEvent(this, "vegaRemove", 7);
-    this.globalSlimmers = {};
-    this.vegaComponentUsageRuntimeMetricsSlimmer = new componentUsageRuntimeMetrics.VegaComponentUsageRuntimeMetricsSlimmer();
-    this.selectionWidgetRenderer = new SelectionWidgetRenderer();
-    this.keyboardController = new SelectionWidgetKeyboardController();
-    this.isSelected = false;
-  }
-  watchIsSelected(newValue) {
-  }
-  render() {
-    return component.sanitizeVegaComponent(index.h(index.Host, null, this.selectionWidgetRenderer.render()), this.host);
-  }
-  get host() { return index.getElement(this); }
-  static get watchers() { return {
-    "isSelected": ["watchIsSelected"]
-  }; }
-};
-__decorate([
-  componentUsageRuntimeMetrics.InjectVegaGlobalSlimmer()
-], VegaRichTextTableSelectionWidget.prototype, "globalSlimmers", void 0);
-__decorate([
-  globalSlimmerRegistry.InjectVegaSlimmer()
-], VegaRichTextTableSelectionWidget.prototype, "vegaComponentUsageRuntimeMetricsSlimmer", void 0);
-__decorate([
-  globalSlimmerRegistry.InjectVegaSlimmer()
-], VegaRichTextTableSelectionWidget.prototype, "selectionWidgetRenderer", void 0);
-__decorate([
-  globalSlimmerRegistry.InjectVegaSlimmer()
-], VegaRichTextTableSelectionWidget.prototype, "keyboardController", void 0);
-VegaRichTextTableSelectionWidget.style = vegaRichTextTableSelectionWidgetCss;
-
-exports.vega_rich_text_table_selection_widget = VegaRichTextTableSelectionWidget;

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,25 +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;
-    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

@@ -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,117 +0,0 @@
-import { generateUUID } from '../../../../../utils/misc';
-import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
-import { AppendChildrenAction } from '../../../dto/actions/append-child-nodes-action';
-import { InsertChildrenAfterAction } from '../../../dto/actions/insert-children-after-block';
-import { InsertChildrenBeforeAction } from '../../../dto/actions/insert-children-before-block';
-import { 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

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