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

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-head-block.d.ts

@@ -0,0 +1,42 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { VegaRTEBlockBase, VegaRTEContentBlock, VegaRTETransformOptions } from '../../../interface';
+import { RTETableBlock } from './table-block';
+import { RTETableRowBlock } from './table-row-block';
+export declare type VegaRTETableHeadBlock = VegaRTEBlockBase & {
+  type: string;
+  children: VegaRTEContentBlock[];
+};
+/**
+ * Class representing a table head block in the rich text editor.
+ */
+export declare class RTETableHeadBlock extends RTEBlock<RTETableBlock, RTETableRowBlock> {
+  type: string;
+  parent: RTETableBlock;
+  children: RTETableRowBlock[];
+  constructor(id: string);
+  /**
+   * @inheritDoc
+   */
+  static from(block: VegaRTETableHeadBlock, options?: VegaRTETransformOptions): RTETableHeadBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTETableBlock): RTETableHeadBlock;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTETableHeadBlock;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-head-cell-block.d.ts

@@ -0,0 +1,30 @@
+import { VegaRTEBlockBase, VegaRTEContentBlock, VegaRTETransformOptions } from '../../../interface';
+import { RTETableRowBlock } from './table-row-block';
+import { RTETableCellBlock } from './table-cell-block';
+export declare type VegaRTETableHeadCellBlock = VegaRTEBlockBase & {
+  type: string;
+  children: VegaRTEContentBlock[];
+};
+/**
+ * Class representing a table head block in the rich text editor.
+ */
+export declare class RTETableHeadCellBlock extends RTETableCellBlock {
+  type: string;
+  constructor(id: string);
+  /**
+   * @inheritDoc
+   */
+  static from(block: VegaRTETableHeadCellBlock, options?: VegaRTETransformOptions): RTETableHeadCellBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTETableRowBlock): RTETableHeadCellBlock;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTETableHeadCellBlock;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-row-block.d.ts

@@ -0,0 +1,44 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { VegaRTEBlockBase, VegaRTETransformOptions } from '../../../interface';
+import { RTETableBodyBlock } from './table-body-block';
+import { RTETableHeadBlock } from './table-head-block';
+import { RTETableCellBlock, VegaRTETableCellBlock } from './table-cell-block';
+import { RTETableHeadCellBlock, VegaRTETableHeadCellBlock } from './table-head-cell-block';
+export declare type VegaRTETableRowBlock = VegaRTEBlockBase & {
+  type: string;
+  children: (VegaRTETableCellBlock | VegaRTETableHeadCellBlock)[];
+};
+/**
+ * Class representing a table row block in the rich text editor.
+ */
+export declare class RTETableRowBlock extends RTEBlock<RTETableBodyBlock | RTETableHeadBlock, RTETableCellBlock | RTETableHeadCellBlock> {
+  type: string;
+  parent: RTETableBodyBlock | RTETableHeadBlock;
+  children: (RTETableCellBlock | RTETableHeadCellBlock)[];
+  constructor(id: string);
+  /**
+   * @inheritDoc
+   */
+  static from(block: VegaRTETableRowBlock, options?: VegaRTETransformOptions): RTETableRowBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTETableBodyBlock | RTETableHeadBlock): RTETableRowBlock;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTETableRowBlock;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-body-renderer.d.ts

@@ -0,0 +1,12 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTETableBodyBlock } from '../dto/table-body-block';
+/**
+ * Renders a table body block in the rich text editor.
+ */
+export declare class RTETableBodyRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableBodyBlock): VegaRTERenderResult;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-caption-renderer.d.ts

@@ -0,0 +1,13 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTETableCaptionBlock } from '../dto/table-caption-block';
+export declare const TABLE_CAPTION_PLACEHOLDER_TEXT: string;
+/**
+ * Renderer for the optional table caption node.
+ */
+export declare class RTETableCaptionRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableCaptionBlock): VegaRTERenderResult;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-cell-renderer.d.ts

@@ -0,0 +1,37 @@
+import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+import { RTETableExtensionContext } from '../table-extension';
+/**
+ * Renders a table cell block in the rich text editor.
+ */
+export declare class RTETableCellRenderer extends VegaRTEExtensionRenderer {
+  private extensionContext;
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableCellBlock, rteContext: RTERenderContext): VegaRTERenderResult;
+  /**
+   * Injects the extension context
+   *
+   * @param {RTETableExtensionContext} context - extension context
+   */
+  injectExtensionContext(context: RTETableExtensionContext): void;
+  /**
+   * Renders the table cell based on its type (td or th).
+   *
+   * @param {VegaRTECreateElementFunction} h - The create element function.
+   * @param {RTETableCellBlock} renderData - The table cell block to render.
+   * @param {RTERenderContext} rteContext - The rte editor context.
+   * @param {'td' | 'th'} elementType - The type of table cell element ('td' or 'th').
+   * @returns {VegaRTERenderResult} - The rendered table cell element.
+   */
+  protected renderByCellType(h: VegaRTECreateElementFunction, renderData: RTETableCellBlock, rteContext: RTERenderContext, elementType: 'td' | 'th'): VegaRTERenderResult;
+  /**
+   * Returns the mouse event listeners for selection handling.
+   *
+   * @param {RTETableCellBlock} renderData - The table cell block to render.
+   * @returns {RTETableSelectionListenersType} - The mouse event listeners.
+   */
+  private onSelectionListeners;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-dynamic-popover-renderer.d.ts

@@ -0,0 +1,51 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { Nullable } from '../../../../../types/general';
+import type { RTETableExtensionContext } from '../table-extension';
+export declare const CONTENT_CLASS_MAP: {
+  [key: string]: string;
+};
+/**
+ * Renderer for a generic, dynamically positioned popover used within table-related extensions.
+ *
+ * - The popover target is based on the current cursor/selection position.
+ * - The popover content is rendered dynamic content.
+ */
+export declare class TableDynamicPopoverRenderer {
+  private popoverRef;
+  private contentRef;
+  private currentType;
+  private getTableRef;
+  private extensionContext;
+  /**
+   * Shows the popover. Before showing, it will refresh the target so
+   * that the popover is positioned relative to the latest cursor position.
+   *
+   * @param {string} type - The table setting type determining which
+   *  content variant to display (for example, table properties or cell properties).
+   */
+  show(type: string): Promise<void>;
+  /**
+   * hide the popover.
+   */
+  hide(): Promise<void>;
+  /**
+   * Injects the RTE extension context.
+   *
+   * @param {RTETableExtensionContext} context - The RTE extension context.
+   */
+  injectRTEExtensionContext(context: RTETableExtensionContext): void;
+  /**
+   * Renders a vega-popover whose target and content are provided dynamically by callers.
+   *
+   * @param {VegaRTECreateElementFunction} h - The create element function.
+   * @param {() => HTMLElement} getTableRef - Current table DOM reference
+   * @returns {VegaRTERenderResult} The rendered popover host.
+   */
+  render(h: VegaRTECreateElementFunction, getTableRef: () => Nullable<HTMLElement>): VegaRTERenderResult;
+  /**
+   * Updates the visibility of the pre-rendered content blocks based on type.
+   *
+   * @param {string} type - The table setting type determining which content variant should be visible.
+   */
+  private updateContent;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-head-cell-renderer.d.ts

@@ -0,0 +1,12 @@
+import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { RTETableCellRenderer } from './table-cell-renderer';
+import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
+/**
+ * Renders a head cell block in the rich text editor.
+ */
+export declare class RTETableHeadCellRenderer extends RTETableCellRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableHeadCellBlock, rteContext: RTERenderContext): VegaRTERenderResult;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-head-renderer.d.ts

@@ -0,0 +1,12 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTETableBlock } from '../dto/table-block';
+/**
+ * Renders a logic control block in the rich text editor.
+ */
+export declare class RTETableHeadRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableBlock): VegaRTERenderResult;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-renderer.d.ts

@@ -0,0 +1,39 @@
+import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTETableBlock } from '../dto/table-block';
+import type { RTETableExtensionContext } from '../table-extension';
+/**
+ * Renderer for the RTETableBlock.
+ */
+export declare class RTETableBlockRenderer extends VegaRTEExtensionRenderer {
+  static readonly EXTENSION_TABLE_CLASS: string;
+  private extensionContext;
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableBlock, rteContext: RTERenderContext): VegaRTERenderResult;
+  /**
+   * @inheritDoc
+   */
+  injectRTEScopeStyles(): string;
+  /**
+   * Injects the RTE extension context.
+   *
+   * @param {RTETableExtensionContext} context - The RTE extension context.
+   */
+  injectExtensionContext(context: RTETableExtensionContext): void;
+  /**
+   * Renders the table element.
+   *
+   * @param {VegaRTECreateElementFunction} h - The create element function.
+   * @param {RTETableBlock} renderData - The table block to render.
+   * @returns {VegaRTERenderResult} - The rendered table element.
+   */
+  private renderTable;
+  /**
+   * Handles the removal of the table block.
+   *
+   * @param {RTETableBlock} renderData - The table block to remove.
+   */
+  private handleTableRemove;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-row-renderer.d.ts

@@ -0,0 +1,12 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTETableRowBlock } from '../dto/table-row-block';
+/**
+ * Renders a logic control block in the rich text editor.
+ */
+export declare class RTETableRowBlockRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableRowBlock): VegaRTERenderResult;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-setting-popover-renderer.d.ts

@@ -0,0 +1,65 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { RTETableBlock } from '../dto/table-block';
+import type { RTETableExtensionContext } from '../table-extension';
+import { TableDynamicPopoverRenderer } from './table-dynamic-popover-renderer';
+/**
+ * Centralizes the popover rendering and interaction logic for table settings.
+ */
+export declare class TableSettingPopoverRenderer {
+  private popoverRef;
+  private tableSettingRef;
+  private tableData;
+  private tableDynamicPopover;
+  private popoverShow;
+  private extensionContext;
+  private settingHandlers;
+  /**
+   * Show table setting popover when table is clicked.
+   * Only the popover belonging to the nearest table will be shown,
+   * which avoids outer tables showing their popover when an inner (nested) table is clicked.
+   *
+   * @param {MouseEvent} event - The MouseEvent that triggered the table action
+   * @param {HTMLElement} trigger - The element that can triggered the popover open.
+   */
+  handleTableClick: (event: MouseEvent, trigger: HTMLElement) => void;
+  /**
+   * Injects the RTE extension context.
+   *
+   * @param {RTETableExtensionContext} context - The RTE extension context.
+   */
+  injectRTEExtensionContext(context: RTETableExtensionContext): void;
+  /**
+   * Sync the selected cells from the table selection to the table setting component.
+   */
+  syncSelectedCells: () => void;
+  /**
+   * Render the popover host and inject the table-setting component with refs wired up.
+   *
+   * @param {VegaRTECreateElementFunction} h - The create element function.
+   * @param {RTETableBlock} renderData - The table block to render.
+   * @param {TableDynamicPopoverRenderer} tableDynamicPopover - Renderer used to show
+   *  the secondary table popover (for example, table-properties-specific settings).
+   * @returns {VegaRTERenderResult} The rendered popover structure.
+   */
+  render(h: VegaRTECreateElementFunction, renderData: RTETableBlock, tableDynamicPopover: TableDynamicPopoverRenderer): VegaRTERenderResult;
+  /**
+   * Updates the table setting component caption state to match the given table data.
+   */
+  private updateTableSettingCaption;
+  /**
+   * Receive setting menu click events.
+   *
+   * @param {CustomEvent<Array<string>>} event - The custom event emitted from the setting menu.
+   */
+  private handleSettingMenuClick;
+  /**
+   * Handles the popover show event to sync the selected table cells to the table setting component.
+   */
+  private handleTableSettingPopoverShow;
+  /**
+   * Collects and returns the currently selected table cells.
+   *
+   * @returns {RTETableCellBlock[]} The array of currently selected table cell blocks.
+   */
+  private getTableSelectedCells;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/setting-event-handlers/caption-operation.d.ts

@@ -0,0 +1,36 @@
+import { Nullable } from '../../../../../types/general';
+import { RTEExtensionContext } from '../../../interface';
+import { RTETableBlock } from '../dto/table-block';
+import { SettingEventHandler } from './setting-event-handler.abstract';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+/**
+ * Event handler for row operations in a table.
+ */
+export declare class CaptionOperationEventHandler extends SettingEventHandler {
+  /**
+   * @inheritDoc
+   */
+  canHandle(action: Array<string>): boolean;
+  /**
+   * Toggle caption state for the target table block when the caption menu item is clicked.
+   *
+   * @param {Array<string>} action - Table setting payload, e.g. ['CAPTION', 'rte-table-caption'].
+   * @param {RTEExtensionContext} _extensionContext - Current editor extension context (unused here).
+   * @param {RTETableBlock} tableBlock - Table block that owns the caption.
+   */
+  execute(action: Array<string>, _extensionContext: RTEExtensionContext, tableBlock: RTETableBlock): void;
+  /**
+   * Applies a cursor update action so the editor focuses on the resolved node.
+   *
+   * @param {RTETableBlock} block - Table block currently being toggled.
+   * @param {Nullable<RTENode>} focusNode - Target node that should receive the caret.
+   */
+  protected syncCursorPosition(block: RTETableBlock, focusNode: Nullable<RTENode>): void;
+  /**
+   * Build a fresh caption block with a default paragraph + placeholder text.
+   *
+   * @param {string} id - table-caption id
+   * @returns {RTETableCaptionBlock} Newly created caption DTO ready for rendering.
+   */
+  private createCaptionBlock;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/setting-event-handlers/column-operation.d.ts

@@ -0,0 +1,55 @@
+import { RTETableExtensionContext } from '../table-extension';
+import { SettingEventHandler } from './setting-event-handler.abstract';
+export declare enum ColumnOperationType {
+  HEADER_COLUMN = "HEADER_COLUMN",
+  ADD_COLUMN_LEFT = "ADD_COLUMN_LEFT",
+  ADD_COLUMN_RIGHT = "ADD_COLUMN_RIGHT",
+  DELETE_COLUMN = "DELETE_COLUMN",
+  SELECT_COLUMN = "SELECT_COLUMN"
+}
+/**
+ * Event handler for column operations in a table.
+ */
+export declare class ColumnOperationEventHandler extends SettingEventHandler {
+  /**
+   * @inheritDoc
+   */
+  canHandle(action: Array<string>): boolean;
+  /**
+   * @inheritDoc
+   */
+  execute(action: Array<string>, extensionContext: RTETableExtensionContext): void;
+  /**
+   * Adds a new column to the table at the specified position.
+   *
+   * @param {ColumnOperationType} direction - The position to insert the new column (left or right).
+   * @param {RTETableCellBlock[] | RTETableHeadCellBlock[]} selectedCells - The selected table cells.
+   */
+  private handleInsertColumn;
+  /**
+   * Deletes the selected column from the table.
+   *
+   * @param {RTETableCellBlock[] | RTETableHeadCellBlock[]} selectedCells - The selected table cells.
+   */
+  private handleDeleteColumn;
+  /**
+   * Selects the entire column in the table.
+   *
+   * @param {RTETableCellBlock[] | RTETableHeadCellBlock[]} selectedCells - The selected table cells.
+   * @param {RTETableExtensionContext} extensionContext - The table extension context.
+   */
+  private handleSelectColumn;
+  /**
+   * Toggles the header state of the selected column in the table.
+   *
+   * @param {RTETableCellBlock[] | RTETableHeadCellBlock[]} selectedCells - The selected table cells.
+   */
+  private handleToggleHeaderColumn;
+  /**
+   * Apply the specified action on the table containing the selected cell.
+   *
+   * @param {DeleteTableColumnAction | InsertTableColumnAction} action - The action to apply.
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} selectedCell - The selected table cell.
+   */
+  private applyActionOnTable;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/setting-event-handlers/row-operation.d.ts

@@ -0,0 +1,61 @@
+import type { RTETableExtensionContext } from '../table-extension';
+import { SettingEventHandler } from './setting-event-handler.abstract';
+export declare enum RowOperationType {
+  HEADER_ROW = "HEADER_ROW",
+  ADD_ROW_ABOVE = "ADD_ROW_ABOVE",
+  ADD_ROW_BELOW = "ADD_ROW_BELOW",
+  DELETE_ROW = "DELETE_ROW",
+  SELECT_ROW = "SELECT_ROW"
+}
+/**
+ * Event handler for row operations in a table.
+ */
+export declare class RowOperationEventHandler extends SettingEventHandler {
+  /**
+   * @inheritDoc
+   */
+  canHandle(action: Array<string>): boolean;
+  /**
+   * @inheritDoc
+   */
+  execute(action: Array<string>, extensionContext: RTETableExtensionContext): void;
+  /**
+   * Adds a new row to the table at the specified position.
+   *
+   * @param {RowOperationType} direction - The position to insert the new row (above or below).
+   * @param {RTETableExtensionContext} extensionContext - The extension context.
+   */
+  private handleInsertRow;
+  /**
+   * Deletes the selected row(s) from the table.
+   *
+   * @param {RTETableExtensionContext} extensionContext - The extension context.
+   */
+  private handleDeleteRow;
+  /**
+   * Converts selected rows to header rows or reverts them back to normal rows.
+   *
+   * @param {RTETableExtensionContext} extensionContext - The extension context.
+   */
+  private handleToggleHeader;
+  /**
+   * Selects the focus row(s) in the table.
+   *
+   * @param {RTETableExtensionContext} extensionContext - The extension context.
+   */
+  private handleSelectRow;
+  /**
+   * Get all selected table rows.
+   *
+   * @param {RTETableExtensionContext} extensionContext - The extension context.
+   * @returns {RTETableRowBlock[]} The selected table row blocks.
+   */
+  private getAllSelectedRows;
+  /**
+   * Applies the given action to the table containing the reference block.
+   *
+   * @param {RTEBlock} refBlock - The reference block within the table.
+   * @param {ModifyContentAction} action - The action to apply to the table.
+   */
+  private applyActionToTable;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/setting-event-handlers/setting-event-handler.abstract.d.ts

@@ -0,0 +1,46 @@
+import { RTEExtensionContext } from '../../../interface';
+import { RTETableBlock } from '../dto/table-block';
+import { Nullable } from '../../../../../types/general';
+import { VegaRTEContent } from '../../../dto/content-state';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+export declare enum TableSettingType {
+  ROW = "ROW",
+  CAPTION = "CAPTION",
+  COLUMN = "COLUMN",
+  MERGE_CELLS = "MERGE_CELLS",
+  TABLE_PROPERTIES = "TABLE_PROPERTIES",
+  CELL_PROPERTIES = "CELL_PROPERTIES"
+}
+/**
+ * Abstract class for setting event handlers.
+ */
+export declare abstract class SettingEventHandler {
+  /**
+   * Applies a cursor update action so the editor focuses on the resolved node.
+   *
+   * @param {RTETableBlock} block - Table block currently being toggled.
+   * @param {Nullable<RTENode>} focusNode - Target node that should receive the caret.
+   */
+  protected syncCursorPosition(block: RTETableBlock, focusNode: Nullable<RTENode>): void;
+  /**
+   * Walks up the parent chain to locate the nearest VegaRTEContent root.
+   *
+   * @param {RTETableBlock} block - Table block used as the starting point.
+   * @returns {Nullable<VegaRTEContent>} Content root containing the table, if found.
+   */
+  protected findRootContent(block: RTETableBlock): Nullable<VegaRTEContent>;
+  /**
+   * Determines if the handler can process the given action.
+   *
+   * @param {Array<string>} action - The action to check.
+   */
+  abstract canHandle(action: Array<string>): void;
+  /**
+   * Determines how to handle the given action.
+   *
+   * @param {Array<string>} action - The action to handle.
+   * @param {RTEExtensionContext} extensionContext - The context for the extension.
+   * @param {RTETableBlock} tableBlock - The table block.
+   */
+  abstract execute(action: Array<string>, extensionContext: RTEExtensionContext, tableBlock: RTETableBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/table-extension.d.ts

@@ -0,0 +1,31 @@
+import { VegaRTEExtension } from '../extension.abstract';
+import { RTEExtensionContext } from '../../interface';
+import { RTETableSelection } from './table-selection';
+export declare type RTETableExtensionContext = RTEExtensionContext & {
+  /**
+   * Table selection manager
+   */
+  tableSelection: RTETableSelection;
+};
+/**
+ * Function extension class for Vega Rich Text Editor.
+ */
+export declare class VegaRTETableExtension extends VegaRTEExtension {
+  private toolbarButtonRenderer;
+  private tableBlockRenderer;
+  private tableRowBlockRenderer;
+  private tableCellRenderer;
+  private tableHeadCellRenderer;
+  private tableSelection;
+  constructor();
+  /**
+   * Initializes the extension with the given context
+   *
+   * @param {RTEExtensionContext} context - extension context
+   */
+  initialExtension(context: RTEExtensionContext): void;
+  /**
+   * @inheritDoc
+   */
+  destroyExtension(): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/table-icon.d.ts

@@ -0,0 +1,3 @@
+import { IconPayload } from '../../../../helpers/icon/interface';
+declare const _default: IconPayload;
+export default _default;