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

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

@@ -18,6 +18,20 @@ export declare class TableCellAnnotationHandler extends TableAnnotationHandlerBa
    * @returns {VegaRTEAnnotations} - Extracted table cell annotation.
    */
   handle(element: HTMLElement): VegaRTEAnnotations;
+  /**
+   * Extract minimum width from element.
+   *
+   * @param {HTMLElement} element - Table cell element.
+   * @returns {Nullable<string>} Minimum width value.
+   */
+  protected getMinWidth(element: HTMLElement): Nullable<string>;
+  /**
+   * Extract box sizing from element.
+   *
+   * @param {HTMLElement} element - Table cell element.
+   * @returns {Nullable<string>} Box sizing value.
+   */
+  protected getBoxSizing(element: HTMLElement): Nullable<string>;
   /**
    * Extract padding from element.
    *

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

@@ -1,38 +1,47 @@
 import { Nullable } from '../../../../../types/general';
 import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
+import { RTETableColorAnnotation } from './table-color-annotation';
 export declare type VegaRTETableAnnotation = {
   backgroundColor?: Nullable<string>;
   border?: Nullable<VegaRTETableBorderType>;
   width?: Nullable<string>;
   height?: Nullable<string>;
   alignment?: Nullable<VegaRTETableAlignment>;
+  borderCollapse?: Nullable<string>;
 };
 export declare type VegaRTETableBorderType = {
-  style: string;
-  width: string;
-  color: string;
+  style?: string;
+  width?: string;
+  color?: string;
 };
 export declare enum RTETableExtensionAnnotationTypeEnum {
   TABLE = "EXTENSION_TABLE",
   CELL = "EXTENSION_TABLE_CELL",
-  CAPTION = "EXTENSION_TABLE_CAPTION"
+  CAPTION = "EXTENSION_TABLE_CAPTION",
+  COLOR = "EXTENSION_TABLE_COLOR"
 }
 export declare type VegaRTETableAlignment = 'left' | 'center' | 'right';
 /**
  * Class representing a table annotation in the rich text editor.
  */
 export declare class RTETableAnnotation extends BlockAnnotation<RTETableExtensionAnnotationTypeEnum.TABLE> {
+  static readonly DEFAULT_BORDER_COLLAPSE: string;
+  static readonly DEFAULT_ALIGNMENT: VegaRTETableAlignment;
   readonly type: RTETableExtensionAnnotationTypeEnum.TABLE;
   backgroundColor?: Nullable<string>;
   border?: Nullable<VegaRTETableBorderType>;
+  backgroundColorAnnotation: RTETableColorAnnotation;
+  borderColorAnnotation: RTETableColorAnnotation;
   width?: Nullable<string>;
   height?: Nullable<string>;
   alignment?: Nullable<VegaRTETableAlignment>;
-  constructor({ backgroundColor, border, width, height, alignment, }?: VegaRTETableAnnotation);
+  borderCollapse?: Nullable<string>;
+  useInternalStyle: boolean;
+  constructor({ backgroundColor, border, width, height, alignment, borderCollapse }?: VegaRTETableAnnotation, useInternalStyle?: boolean);
   /**
    * @inheritDoc
    */
-  static from(value: VegaRTETableAnnotation): [RTETableExtensionAnnotationTypeEnum.TABLE, RTETableAnnotation];
+  static from(value: VegaRTETableAnnotation, useInternalStyle?: boolean): [RTETableExtensionAnnotationTypeEnum.TABLE, RTETableAnnotation];
   /**
    * Generates the CSS border string from the border properties.
    *

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

@@ -2,6 +2,7 @@ import { Nullable } from '../../../../../types/general';
 import { RTETableExtensionAnnotationTypeEnum, VegaRTETableBorderType } from './table-annotation';
 import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
 import { RTERenderContext } from '../../../interface';
+import { RTETableColorAnnotation } from './table-color-annotation';
 export declare type VegaRTETableCellAnnotation = {
   backgroundColor?: Nullable<string>;
   padding?: Nullable<string>;
@@ -10,6 +11,8 @@ export declare type VegaRTETableCellAnnotation = {
   height?: Nullable<string>;
   textAlign?: Nullable<VegaRTETableTextAlignType>;
   verticalAlign?: Nullable<VegaRTETableVerticalAlignType>;
+  minWidth?: Nullable<string>;
+  boxSizing?: Nullable<string>;
 };
 export declare type VegaRTETableTextAlignType = 'left' | 'center' | 'right' | 'justify';
 export declare type VegaRTETableVerticalAlignType = 'top' | 'middle' | 'bottom';
@@ -22,6 +25,7 @@ export declare class RTETableCellAnnotation extends BlockAnnotation<RTETableExte
   static readonly DEFAULT_HORIZONTAL_TEXT_ALIGN: VegaRTETableTextAlignType;
   static readonly DEFAULT_VERTICAL_TEXT_ALIGN: VegaRTETableVerticalAlignType;
   static readonly DEFAULT_CELL_MIN_WIDTH: string;
+  static readonly DEFAULT_BOX_SIZING: string;
   readonly type: RTETableExtensionAnnotationTypeEnum.CELL;
   backgroundColor?: Nullable<string>;
   padding?: Nullable<string>;
@@ -30,11 +34,16 @@ export declare class RTETableCellAnnotation extends BlockAnnotation<RTETableExte
   height?: Nullable<string>;
   textAlign?: Nullable<VegaRTETableTextAlignType>;
   verticalAlign?: Nullable<VegaRTETableVerticalAlignType>;
-  constructor({ backgroundColor, padding, border, width, height, textAlign, verticalAlign, }?: VegaRTETableCellAnnotation);
+  backgroundColorAnnotation: RTETableColorAnnotation;
+  borderColorAnnotation: RTETableColorAnnotation;
+  minWidth?: Nullable<string>;
+  boxSizing?: Nullable<string>;
+  useInternalStyle: boolean;
+  constructor({ backgroundColor, padding, border, width, height, textAlign, verticalAlign, minWidth, boxSizing, }?: VegaRTETableCellAnnotation, useInternalStyle?: boolean);
   /**
    * @inheritDoc
    */
-  static from(cellAnnotation: VegaRTETableCellAnnotation): [RTETableExtensionAnnotationTypeEnum.CELL, RTETableCellAnnotation];
+  static from(cellAnnotation: VegaRTETableCellAnnotation, useInternalStyle?: boolean): [RTETableExtensionAnnotationTypeEnum.CELL, RTETableCellAnnotation];
   /**
    * Generates the CSS border string from the border properties.
    *

package/dist/types/components/vega-rich-text-editor/extensions/table/annotations/table-color-annotation.d.ts

@@ -0,0 +1,43 @@
+import { Nullable } from '../../../../../types/general';
+import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
+import { AnnotationStyle } from '../../../interface';
+import { RTETableExtensionAnnotationTypeEnum } from './table-annotation';
+/**
+ * Class representing a table color annotation in the rich text editor.
+ */
+export declare class RTETableColorAnnotation extends BlockAnnotation<RTETableExtensionAnnotationTypeEnum.COLOR> {
+  type: RTETableExtensionAnnotationTypeEnum.COLOR;
+  private color;
+  constructor(colorKey?: string);
+  /**
+   * Render the style for the annotation
+   *
+   * @returns {AnnotationStyle} The style object containing the color
+   */
+  renderStyle(): AnnotationStyle;
+  /**
+   * Render the CSS class for the annotation
+   *
+   * @returns {Nullable<string>} Always returns null as no CSS class is used
+   */
+  renderClass(): Nullable<string>;
+  /**
+   * Convert the annotation to a JSON representation
+   *
+   * @returns {Record<string, string>} A JSON object containing the color key
+   */
+  toJSON(): Record<string, string>;
+  /**
+   * Clone the current annotation
+   *
+   * @returns {BlockAnnotation<RTETableExtensionAnnotationTypeEnum.COLOR>} A new instance of RTETableColorAnnotation with the same color key
+   */
+  clone(): BlockAnnotation<RTETableExtensionAnnotationTypeEnum.COLOR>;
+  /**
+   * format table color
+   *
+   * @param {string} colorKey - table color
+   * @returns {Nullable<VegaRTEColorSchema>} - VegaRTEColorSchema
+   */
+  private formatColor;
+}

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

@@ -6,11 +6,11 @@ import { RTETableCellAnnotation, VegaRTETableCellAnnotation } from './table-cell
  */
 export declare class RTETableHeadCellAnnotation extends RTETableCellAnnotation {
   static readonly DEFAULT_BACKGROUND_COLOR: string;
-  constructor(annotation?: VegaRTETableCellAnnotation);
+  constructor(annotation?: VegaRTETableCellAnnotation, useInternalStyle?: boolean);
   /**
    * @inheritDoc
    */
-  static from(cellAnnotation: VegaRTETableCellAnnotation): [RTETableExtensionAnnotationTypeEnum.CELL, RTETableHeadCellAnnotation];
+  static from(cellAnnotation: VegaRTETableCellAnnotation, useInternalStyle?: boolean): [RTETableExtensionAnnotationTypeEnum.CELL, RTETableHeadCellAnnotation];
   /**
    * @inheritDoc
    */

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

@@ -1,3 +1,3 @@
-import { RTETableColorSchema } from '../../../interface';
+import { VegaRTEColorSchema } from '../../../interface';
 export declare const RTE_TABLE_BORDER_STYLES: string[];
-export declare const RTE_TABLE_DEFAULT_COLORS: RTETableColorSchema[];
+export declare const RTE_TABLE_DEFAULT_COLORS: VegaRTEColorSchema[];

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

@@ -34,6 +34,18 @@ export declare class RTETableCellBlock extends RTEBlock<RTETableRowBlock, RTEBlo
    * @inheritDoc
    */
   isNotEmpty(): boolean;
+  /**
+   * Get the rowSpan of the table cell
+   *
+   * @returns {number} - rowSpan value
+   */
+  get rowSpan(): number;
+  /**
+   * Get the colSpan of the table cell
+   *
+   * @returns {number} - colSpan value
+   */
+  get colSpan(): number;
   /**
    * @inheritDoc
    */
@@ -42,4 +54,11 @@ export declare class RTETableCellBlock extends RTEBlock<RTETableRowBlock, RTEBlo
    * @inheritDoc
    */
   toJSON(): VegaRTETableCellBlock;
+  /**
+   * Get custom attribute by name
+   *
+   * @param {string} attrName - attribute name
+   * @returns {Nullable<string>} - attribute value
+   */
+  private getCustomAttributeByName;
 }

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

@@ -1,4 +1,4 @@
-import { RTETableColorSchema, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEColorSchema, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
 import { Nullable } from '../../../../../types/general';
 import type { RTETableExtensionContext } from '../table-extension';
 import { RTETableBlock } from '../dto/table-block';
@@ -21,7 +21,7 @@ export declare class TableDynamicPopoverRenderer {
   private popoverCloseType;
   private tablePropertiesHandlerMap;
   private cellPropertiesHandlerMap;
-  constructor(colors: RTETableColorSchema[]);
+  constructor(colors: VegaRTEColorSchema[]);
   /**
    * removes the multi-cell selection anchor element from the DOM, if present,
    * and clears the internal reference.

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

@@ -1,4 +1,4 @@
-import { RTETableColorSchema, RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
 import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
 import { RTETableBlock } from '../dto/table-block';
 import type { RTETableExtensionContext } from '../table-extension';
@@ -7,7 +7,6 @@ import type { RTETableExtensionContext } from '../table-extension';
  */
 export declare class RTETableBlockRenderer extends VegaRTEExtensionRenderer {
   private extensionContext;
-  private tableColorSchema;
   private popoverRenders;
   /**
    * @inheritDoc
@@ -23,12 +22,6 @@ export declare class RTETableBlockRenderer extends VegaRTEExtensionRenderer {
    * @param {RTETableExtensionContext} context - The RTE extension context.
    */
   injectExtensionContext(context: RTETableExtensionContext): void;
-  /**
-   * Updates the table color schema.
-   *
-   * @param {RTETableColorSchema[]} colors - The new table color schema.
-   */
-  updateTableColorSchema(colors: RTETableColorSchema[]): void;
   /**
    * Renders the table element.
    *

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

@@ -0,0 +1,44 @@
+import { RTETableExtensionContext } from '../table-extension';
+import { SettingEventHandler } from './setting-event-handler.abstract';
+export declare enum MergeCellsOperationType {
+  MERGE_CELLS = "MERGE_CELLS",
+  MERGE_CELL_UP = "MERGE_CELL_UP",
+  MERGE_CELL_RIGHT = "MERGE_CELL_RIGHT",
+  MERGE_CELL_DOWN = "MERGE_CELL_DOWN",
+  MERGE_CELL_LEFT = "MERGE_CELL_LEFT"
+}
+/**
+ * Event handler for merge cells operations in a table.
+ */
+export declare class MergeCellsOperationEventHandler extends SettingEventHandler {
+  /**
+   * @inheritDoc
+   */
+  canHandle(action: Array<string>): boolean;
+  /**
+   * @inheritDoc
+   */
+  execute(action: Array<string>, extensionContext: RTETableExtensionContext): void;
+  /**
+   * Get the adjacent cell in the specified direction.
+   *
+   * @param {MergeCellsOperationType} direction - The direction to look for the adjacent cell.
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} cell - The current cell.
+   * @returns {Array<RTETableCellBlock | RTETableHeadCellBlock>} Array containing the cells to merge.
+   */
+  private getDirectionMergeCells;
+  /**
+   * Handle the merge cells operation by creating and applying a MergeCellsAction.
+   *
+   * @param {Array<RTETableCellBlock | RTETableHeadCellBlock>} mergeCells - The cells to merge.
+   * @param {MergeCellsOperationType} direction - The merge cell direction.
+   */
+  private handleMergeCells;
+  /**
+   * Apply the specified action on the table containing the selected cell.
+   *
+   * @param {MergeCellsAction} 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/setting-event-handler.abstract.d.ts

@@ -9,7 +9,8 @@ export declare enum TableSettingType {
   COLUMN = "COLUMN",
   MERGE_CELLS = "MERGE_CELLS",
   TABLE = "TABLE",
-  CELL = "CELL"
+  CELL = "CELL",
+  SPLIT_CELL = "SPLIT_CELL"
 }
 /**
  * Abstract class for setting event handlers.

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

@@ -0,0 +1,31 @@
+import { RTETableExtensionContext } from '../table-extension';
+import { SettingEventHandler } from './setting-event-handler.abstract';
+export declare enum SplitCellOperationType {
+  SPLIT_CELL_HORIZONTALLY = "SPLIT_CELL_HORIZONTALLY",
+  SPLIT_CELL_VERTICALLY = "SPLIT_CELL_VERTICALLY"
+}
+/**
+ * Event handler for split cell operations in a table.
+ */
+export declare class SplitCellOperationEventHandler extends SettingEventHandler {
+  /**
+   * @inheritDoc
+   */
+  canHandle(action: Array<string>): boolean;
+  /**
+   * @inheritDoc
+   */
+  execute(action: Array<string>, extensionContext: RTETableExtensionContext): void;
+  /**
+   * Splits the selected table cell horizontally (split top/bottom).
+   *
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} selectedCell - The table cell block to split.
+   */
+  private handleSplitCellHorizontally;
+  /**
+   * Splits the selected table cell vertically (split left/right).
+   *
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} selectedCell - The table cell block to split.
+   */
+  private handleSplitCellVertically;
+}

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

@@ -1,5 +1,5 @@
 import { VegaRTEExtension } from '../extension.abstract';
-import { RTEExtensionContext, RTETableColorSchema } from '../../interface';
+import { RTEExtensionContext, VegaRTEColorSchema } from '../../interface';
 import { RTETableSelection } from './table-selection';
 export declare type RTETableExtensionContext = RTEExtensionContext & {
   /**
@@ -20,9 +20,9 @@ export declare class VegaRTETableExtension extends VegaRTEExtension {
   /**
    * Instantiate the table extension
    *
-   * @param {RTETableColorSchema[]} colors - The table border color and background color list.
+   * @param {VegaRTEColorSchema[]} colors - The table border color and background color list.
    */
-  constructor(colors?: RTETableColorSchema[]);
+  constructor(colors?: VegaRTEColorSchema[]);
   /**
    * Initializes the extension with the given context
    *

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

@@ -34,6 +34,21 @@ export declare class RTETableSelection {
    * @returns {(RTETableCellBlock | RTETableHeadCellBlock)[]} All cells in the rectangular selection area.
    */
   static computeRectRange(anchor: RTETableCellBlock | RTETableHeadCellBlock, focus: RTETableCellBlock | RTETableHeadCellBlock): (RTETableCellBlock | RTETableHeadCellBlock)[];
+  /**
+   * Get the rowSpan and colSpan attributes from a cell's DOM element.
+   *
+   * @param {RTETableCellBlock} cell - The cell to get span values from.
+   * @returns {CellSpanType} Object with rowSpan and colSpan properties.
+   */
+  private static getCellSpan;
+  /**
+   * Build a grid representation of the table that accounts for rowSpan and colSpan.
+   * Each cell in the grid array points to the actual cell block that occupies that position.
+   *
+   * @param {RTETableRowBlock[]} allRows - All rows in the table.
+   * @returns {CellGridMetaType} Object with grid and cellMeta properties.
+   */
+  private static buildCellGrid;
   /**
    * Clean up event listeners.
    */

package/dist/types/components/vega-rich-text-editor/extensions/table/utils/table-color-manager.d.ts

@@ -0,0 +1,26 @@
+import { VegaRTEColorSchema } from '../../../interface';
+/**
+ * Manages table colors for the rich text editor.
+ */
+export declare class RTETableColorManager {
+  static TABLE_COLORS: VegaRTEColorSchema[];
+  /**
+   * Get the list of table colors.
+   *
+   * @returns {VegaRTEColorSchema[]} - Array of table colors.
+   */
+  static getTableColors(): VegaRTEColorSchema[];
+  /**
+   * Set the list of table colors.
+   *
+   * @param {VegaRTEColorSchema[]} colors - Array of table colors.
+   */
+  static setTableColors(colors: VegaRTEColorSchema[]): void;
+  /**
+   * Get color key from color value
+   *
+   * @param {string} colorValue - color value
+   * @returns {string} - color key
+   */
+  static getColorKey(colorValue: string): string;
+}

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

@@ -4,8 +4,10 @@ import { RTEBlock } from '../../../dto/blocks/block.abstract';
 import { RTENode } from '../../../dto/nodes/node.abstract';
 import { RTETableBlock } from '../dto/table-block';
 import { VegaRTETableBodyBlock } from '../dto/table-body-block';
-import { VegaRTETableCellBlock } from '../dto/table-cell-block';
-import { VegaRTETableRowBlock, RTETableRowBlock } from '../dto/table-row-block';
+import { RTETableCellBlock, VegaRTETableCellBlock } from '../dto/table-cell-block';
+import { RTETableRowBlock, VegaRTETableRowBlock } from '../dto/table-row-block';
+import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
+import { MergeCellsOperationType } from '../setting-event-handlers/merge-cells-operation';
 /**
  * Recursively searches for a parent block of a specific type.
  *
@@ -51,3 +53,101 @@ export declare function getFirstNode(block: Nullable<RTEBlock>): Nullable<RTENod
  * @returns {VegaRTETableCellBlock} The default cell block template.
  */
 export declare function getDefaultCellBlockTemplate(cellType: string): VegaRTETableCellBlock;
+export declare type CellSpan = {
+  colSpan: number;
+  rowSpan: number;
+};
+/**
+ * Get the actual col span and row span of a cell.
+ *
+ * @param {RTETableCellBlock | RTETableHeadCellBlock} cell - The cell to check.
+ * @returns {CellSpan} The actual span values.
+ */
+export declare function getCellSpan(cell: RTETableCellBlock | RTETableHeadCellBlock): CellSpan;
+/**
+ * Get the actual column position of a cell considering previous cells' colspan
+ * and cells from previous rows with rowspan that extend into the current row.
+ *
+ * @param {RTETableCellBlock | RTETableHeadCellBlock} cell - The cell to check.
+ * @param {RTETableRowBlock[]} allRows - The table all rows.
+ * @returns {number} The actual column position.
+ */
+export declare function getActualColumnPosition(cell: RTETableCellBlock | RTETableHeadCellBlock, allRows: RTETableRowBlock[]): number;
+/**
+ * Build a 2D grid representation of a table section where each occupied position
+ * contains the cell id covering that (row, col) coordinate, accounting for colSpan/rowSpan.
+ *
+ * @param {RTETableRowBlock[]} allRows - All rows in the current table section.
+ * @returns {string[][]} The table grid.
+ */
+export declare function buildTableGrid(allRows: RTETableRowBlock[]): string[][];
+export declare type AdjacentCellDirection = 'up' | 'right' | 'down' | 'left';
+/**
+ * Get the adjacent cell in the specified direction based on the table matrix.
+ *
+ * @param {RTETableCellBlock | RTETableHeadCellBlock} cell - The current cell.
+ * @param {AdjacentCellDirection} direction - The direction to locate the adjacent cell.
+ * @returns {RTETableCellBlock | RTETableHeadCellBlock | null} The adjacent cell or null.
+ */
+export declare function getAdjacentCell(cell: RTETableCellBlock | RTETableHeadCellBlock, direction: MergeCellsOperationType): RTETableCellBlock | RTETableHeadCellBlock | null;
+/**
+ * Find the cell that covers the specified matrix position.
+ *
+ * @param {RTETableRowBlock[]} rows - Rows in the current table section.
+ * @param {number} targetRowIndex - Target matrix row index.
+ * @param {number} targetColPosition - Target matrix column position.
+ * @returns {RTETableCellBlock | RTETableHeadCellBlock | null} The covering cell or null.
+ */
+export declare function findCellAtPosition(rows: RTETableRowBlock[], targetRowIndex: number, targetColPosition: number): RTETableCellBlock | RTETableHeadCellBlock | null;
+/**
+ * Rectangular bounds information for selected table cells.
+ */
+export declare type RectangularBounds = {
+  minRow: number;
+  maxRow: number;
+  minCol: number;
+  maxCol: number;
+  targetCell: RTETableCellBlock | RTETableHeadCellBlock;
+  coveredPositions: Set<string>;
+};
+/**
+ * Get the rectangular bounds of selected cells.
+ * Calculates the bounding box (minRow, maxRow, minCol, maxCol) and returns related information.
+ *
+ * @param {RTETableCellBlock[] | RTETableHeadCellBlock[]} selectedCells - The selected table cells.
+ * @returns {RectangularBounds} The rectangular bounds' information.
+ */
+export declare function getRectangularBounds(selectedCells: RTETableCellBlock[] | RTETableHeadCellBlock[]): RectangularBounds;
+/**
+ * Calculate the total number of columns in the table.
+ * Accounts for cells with col span.
+ *
+ * @param {RTETableBlock} table - The table block.
+ * @returns {number} The total number of columns in the table.
+ */
+export declare function getTableColumnCount(table: RTETableBlock): number;
+/**
+ * Check if the selected cells form a rectangular area.
+ * Considers cells with col span and row span.
+ *
+ * @param {RTETableCellBlock[] | RTETableHeadCellBlock[]} selectedCells - The selected table cells.
+ * @returns {boolean} True if the selected cells form a rectangle, false otherwise.
+ */
+export declare function isRectangularSelection(selectedCells: RTETableCellBlock[] | RTETableHeadCellBlock[]): boolean;
+/**
+ * Set the col span and row span attributes for a target cell.
+ * When colSpan equals the table's total columns, rowSpan is removed.
+ *
+ * @param {RTETableCellBlock | RTETableHeadCellBlock} targetCell - The target cell to set attributes on.
+ * @param {number} colSpan - The column span value.
+ * @param {number} rowSpan - The row span value.
+ * @param {RTETableBlock} table - The table block.
+ */
+export declare function setSpanAttributes(targetCell: RTETableCellBlock | RTETableHeadCellBlock, colSpan: number, rowSpan: number, table: RTETableBlock): void;
+/**
+ * Create a new cell of the specified type.
+ *
+ * @param {string} cellType - The type of cell ('table-cell' or 'table-head-cell').
+ * @returns {RTETableCellBlock | RTETableHeadCellBlock} The newly created cell.
+ */
+export declare function createNewCell(cellType: string): RTETableCellBlock | RTETableHeadCellBlock;

package/dist/types/components/vega-rich-text-editor/extensions/table/vega-rich-text-table-properties/slimmers/controllers/vega-rich-text-table-properties-color-controller.d.ts

@@ -5,10 +5,25 @@ import { VegaRichTextTableProperties } from '../../vega-rich-text-table-properti
  */
 export declare class TableColorController extends VegaSlimmer {
   protected colors: VegaRichTextTableProperties['colors'];
+  protected isInDarkMode: VegaRichTextTableProperties['isInDarkMode'];
   /**
    * Returns an array of light color values from the color schema.
    *
    * @returns {string[]} An array of light color strings.
    */
-  getLightColors(): string[];
+  getColors(): string[];
+  /**
+   * Returns the color key corresponding to the provided color value.
+   *
+   * @param {string} color - The color value to find the key for.
+   * @returns {string} The key of the color schema that matches the provided color value.
+   */
+  getColorKey(color: string): string;
+  /**
+   * Returns the color value corresponding to the provided color key.
+   *
+   * @param {string} colorKey - The color key to find the value for.
+   * @returns {string} The value of the color schema that matches the provided color key.
+   */
+  getColorByKey(colorKey: string): string;
 }

package/dist/types/components/vega-rich-text-editor/extensions/table/vega-rich-text-table-properties/slimmers/renderers/vega-rich-text-table-properties-basic-form-field-renderer.abstract.d.ts

@@ -34,12 +34,6 @@ export declare abstract class VegaRichTextTablePropertiesBaseFormFieldRenderer e
    * @returns { HTMLElement } The dimension fields element.
    */
   protected renderDimensionFields(withPadding?: boolean): HTMLElement;
-  /**
-   * Emit a change event on each form field value change.
-   *
-   * @param {HTMLElement} el - The form field element.
-   */
-  protected handleFormChange: (el: HTMLElement) => void;
   protected renderAlignmentField(alignmentList: string[], iconPrefix: string, formFieldName: string): HTMLElement;
   /**
    * Render save and cancel action buttons.
@@ -47,6 +41,12 @@ export declare abstract class VegaRichTextTablePropertiesBaseFormFieldRenderer e
    * @returns {HTMLElement} The action buttons element.
    */
   protected renderActionButtons(): HTMLElement;
+  /**
+   * Emit a change event on each form field value change.
+   *
+   * @param {HTMLElement} el - The form field element.
+   */
+  protected handleFormChange: (el: HTMLElement) => void;
   /**
    * Emit a change event on each form field value change.
    *
@@ -84,6 +84,18 @@ export declare abstract class VegaRichTextTablePropertiesBaseFormFieldRenderer e
    * @param {HTMLElement} colorPickerRef - The border color field element.
    */
   private updateBorderDisplayColor;
+  /**
+   * Handle background color picker change event.
+   *
+   * @param {HTMLElement} el - The background color picker element.
+   */
+  private handleBackgroundColorPickerChange;
+  /**
+   * Update the background color display when background color changes.
+   *
+   * @param {HTMLElement} colorInput - The background color field element.
+   */
+  private updateBackgroundDisplayColor;
   /**
    * Clear background color value.
    *

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

@@ -7,7 +7,7 @@ export declare class VegaRichTextTablePropertiesRenderer extends VegaSlimmer {
   protected cellFormRenderer: VegaRichTextTableProperties['cellFormRenderer'];
   private formRef;
   private formTouched;
-  watchDefaultValueChange(newValue: RTETablePropertiesType): void;
+  initialFormState(newValue: RTETablePropertiesType): void;
   getFormRef(): HTMLVegaFormElement;
   /**
    * Mark the form as touched.
@@ -30,4 +30,10 @@ export declare class VegaRichTextTablePropertiesRenderer extends VegaSlimmer {
    * Reset the touch state.
    */
   private resetTouchedState;
+  /**
+   * Handle color related fields before setting form value to ensure change event is triggered.
+   *
+   * @param {RTETablePropertiesType} formValue - The form value to be set.
+   */
+  private resetColorRelatedFields;
 }