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

package/dist/collection/components/vega-rich-text-editor/extensions/table/setting-event-handlers/cell-properties.js

@@ -15,7 +15,6 @@ import { UpdateCursorPositionAction } from '../../../dto/actions/update-cursor-p
 import { RTETableCellAnnotationsAction } from '../actions/table-cell-annotations-action';
 import { RTETableHeadCellAnnotationsAction } from '../actions/table-head-cell-annotations-action';
 import { RTETableExtensionAnnotationTypeEnum } from '../annotations/table-annotation';
-import { RTETableCellAnnotation } from '../annotations/table-cell-annotation';
 import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
 /**
  * Event handler for cell properties in a table.
@@ -30,14 +29,17 @@ export class CellPropertiesEventHandler {
   static getStyleCollectionFromCell(selectedCells) {
     return selectedCells.reduce((accumulator, cell) => {
       const annotation = cell.getAnnotationByType(RTETableExtensionAnnotationTypeEnum.CELL);
-      const _a = annotation.toJSON().tableCell, { border } = _a, restProps = __rest(_a, ["border"]);
-      const formattedBorder = {};
-      if (border) {
-        formattedBorder.borderStyle = border.style;
-        formattedBorder.borderColor = border.color;
-        formattedBorder.borderWidth = border.width;
+      accumulator[cell.id] = {};
+      if (annotation) {
+        const _a = annotation.toJSON().tableCell, { border } = _a, restProps = __rest(_a, ["border"]);
+        const formattedBorder = {};
+        if (border) {
+          formattedBorder.borderStyle = border.style;
+          formattedBorder.borderColor = border.color;
+          formattedBorder.borderWidth = border.width;
+        }
+        accumulator[cell.id] = cleanObject(Object.assign(Object.assign({}, restProps), formattedBorder));
       }
-      accumulator[cell.id] = cleanObject(Object.assign(Object.assign({}, restProps), formattedBorder));
       return accumulator;
     }, {});
   }
@@ -69,7 +71,7 @@ export class CellPropertiesEventHandler {
         mergedStyles[key] = styleValues[0];
       }
     }
-    return Object.assign({ borderColor: RTETableCellAnnotation.DEFAULT_BORDER.color, borderStyle: RTETableCellAnnotation.DEFAULT_BORDER.style, borderWidth: RTETableCellAnnotation.DEFAULT_BORDER.width, textAlign: RTETableCellAnnotation.DEFAULT_HORIZONTAL_TEXT_ALIGN, verticalAlign: RTETableCellAnnotation.DEFAULT_VERTICAL_TEXT_ALIGN }, mergedStyles);
+    return mergedStyles;
   }
   /**
    * Apply the given properties to the selected cells
@@ -107,12 +109,14 @@ export class CellPropertiesEventHandler {
    */
   convertToVegaTableCellAnnotation(originalStyles) {
     const { borderStyle, borderWidth, borderColor } = originalStyles, restStyles = __rest(originalStyles, ["borderStyle", "borderWidth", "borderColor"]);
-    const border = {
-      style: borderStyle || RTETableCellAnnotation.DEFAULT_BORDER.style,
-      width: parseToPixelString(borderWidth || RTETableCellAnnotation.DEFAULT_BORDER.width),
-      color: borderColor || RTETableCellAnnotation.DEFAULT_BORDER.color,
-    };
-    return Object.assign(Object.assign({}, restStyles), { padding: restStyles.padding ? parseToPixelString(restStyles.padding) : '', width: restStyles.width ? parseToPixelString(restStyles.width) : '', height: restStyles.height ? parseToPixelString(restStyles.height) : '', border });
+    const border = borderStyle || borderColor || borderWidth
+      ? cleanObject({
+        style: borderStyle,
+        width: borderWidth ? parseToPixelString(borderWidth) : '',
+        color: borderColor,
+      })
+      : null;
+    return cleanObject(Object.assign(Object.assign({}, restStyles), { padding: restStyles.padding ? parseToPixelString(restStyles.padding) : '', width: restStyles.width ? parseToPixelString(restStyles.width) : '', height: restStyles.height ? parseToPixelString(restStyles.height) : '', border }));
   }
   /**
    * Apply the given annotation to the specified table cell

package/dist/collection/components/vega-rich-text-editor/extensions/table/setting-event-handlers/merge-cells-operation.js

@@ -0,0 +1,100 @@
+import { SettingEventHandler, TableSettingType } from './setting-event-handler.abstract';
+import { RTETableBlock } from '../dto/table-block';
+import { MergeCellsAction } from '../actions/merge-cells-action';
+import { getRectangularBounds, getParentBlockByType, getAdjacentCell, } from '../utils/utils';
+export var MergeCellsOperationType;
+(function (MergeCellsOperationType) {
+  MergeCellsOperationType["MERGE_CELLS"] = "MERGE_CELLS";
+  MergeCellsOperationType["MERGE_CELL_UP"] = "MERGE_CELL_UP";
+  MergeCellsOperationType["MERGE_CELL_RIGHT"] = "MERGE_CELL_RIGHT";
+  MergeCellsOperationType["MERGE_CELL_DOWN"] = "MERGE_CELL_DOWN";
+  MergeCellsOperationType["MERGE_CELL_LEFT"] = "MERGE_CELL_LEFT";
+})(MergeCellsOperationType || (MergeCellsOperationType = {}));
+/**
+ * Event handler for merge cells operations in a table.
+ */
+export class MergeCellsOperationEventHandler extends SettingEventHandler {
+  /**
+   * @inheritDoc
+   */
+  canHandle(action) {
+    return action[0] === TableSettingType.MERGE_CELLS;
+  }
+  /**
+   * @inheritDoc
+   */
+  execute(action, extensionContext) {
+    const selectedCells = extensionContext.tableSelection.getSelectedCells();
+    const operation = action[1];
+    switch (operation) {
+      case MergeCellsOperationType.MERGE_CELL_UP:
+      case MergeCellsOperationType.MERGE_CELL_RIGHT:
+      case MergeCellsOperationType.MERGE_CELL_DOWN:
+      case MergeCellsOperationType.MERGE_CELL_LEFT:
+        {
+          const mergeCells = this.getDirectionMergeCells(operation, selectedCells[0]);
+          this.handleMergeCells(mergeCells, operation);
+        }
+        break;
+      default:
+        {
+          if (selectedCells.length > 1) {
+            this.handleMergeCells(selectedCells, MergeCellsOperationType.MERGE_CELLS);
+          }
+        }
+        break;
+    }
+  }
+  /**
+   * 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.
+   */
+  getDirectionMergeCells(direction, cell) {
+    const adjacent = getAdjacentCell(cell, direction);
+    if (!adjacent) {
+      return [cell];
+    }
+    switch (direction) {
+      case MergeCellsOperationType.MERGE_CELL_UP:
+        return [adjacent, cell];
+      case MergeCellsOperationType.MERGE_CELL_DOWN:
+        return [cell, adjacent];
+      case MergeCellsOperationType.MERGE_CELL_LEFT:
+        return [adjacent, cell];
+      default:
+        return [cell, adjacent];
+    }
+  }
+  /**
+   * 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.
+   */
+  handleMergeCells(mergeCells, direction) {
+    if (mergeCells.length < 2) {
+      return;
+    }
+    const rectInfo = getRectangularBounds(mergeCells);
+    const { minRow, maxRow, minCol, maxCol, targetCell } = rectInfo;
+    const colSpan = maxCol - minCol + 1;
+    const rowSpan = maxRow - minRow + 1;
+    const action = new MergeCellsAction(targetCell, mergeCells, colSpan, rowSpan, direction);
+    this.applyActionOnTable(action, targetCell);
+  }
+  /**
+   * 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.
+   */
+  applyActionOnTable(action, selectedCell) {
+    const table = getParentBlockByType(selectedCell, RTETableBlock);
+    if (table) {
+      table.apply(action);
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/table/setting-event-handlers/setting-event-handler.abstract.js

@@ -8,6 +8,7 @@ export var TableSettingType;
   TableSettingType["MERGE_CELLS"] = "MERGE_CELLS";
   TableSettingType["TABLE"] = "TABLE";
   TableSettingType["CELL"] = "CELL";
+  TableSettingType["SPLIT_CELL"] = "SPLIT_CELL";
 })(TableSettingType || (TableSettingType = {}));
 /**
  * Abstract class for setting event handlers.

package/dist/collection/components/vega-rich-text-editor/extensions/table/setting-event-handlers/split-cell-operation.js

@@ -0,0 +1,57 @@
+import { SplitCellHorizontallyAction } from '../actions/split-cell-horizontally-action';
+import { SplitCellVerticallyAction } from '../actions/split-cell-vertically-action';
+import { SettingEventHandler, TableSettingType } from './setting-event-handler.abstract';
+export var SplitCellOperationType;
+(function (SplitCellOperationType) {
+  SplitCellOperationType["SPLIT_CELL_HORIZONTALLY"] = "SPLIT_CELL_HORIZONTALLY";
+  SplitCellOperationType["SPLIT_CELL_VERTICALLY"] = "SPLIT_CELL_VERTICALLY";
+})(SplitCellOperationType || (SplitCellOperationType = {}));
+/**
+ * Event handler for split cell operations in a table.
+ */
+export class SplitCellOperationEventHandler extends SettingEventHandler {
+  /**
+   * @inheritDoc
+   */
+  canHandle(action) {
+    return action[0] === TableSettingType.SPLIT_CELL;
+  }
+  /**
+   * @inheritDoc
+   */
+  execute(action, extensionContext) {
+    const selectedCells = extensionContext.tableSelection.getSelectedCells();
+    if (selectedCells && selectedCells.length === 1) {
+      const targetCell = selectedCells[0];
+      const operation = action[1];
+      switch (operation) {
+        case SplitCellOperationType.SPLIT_CELL_HORIZONTALLY:
+          this.handleSplitCellHorizontally(targetCell);
+          break;
+        case SplitCellOperationType.SPLIT_CELL_VERTICALLY:
+          this.handleSplitCellVertically(targetCell);
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  /**
+   * Splits the selected table cell horizontally (split top/bottom).
+   *
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} selectedCell - The table cell block to split.
+   */
+  handleSplitCellHorizontally(selectedCell) {
+    const action = new SplitCellHorizontallyAction();
+    selectedCell.apply(action);
+  }
+  /**
+   * Splits the selected table cell vertically (split left/right).
+   *
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} selectedCell - The table cell block to split.
+   */
+  handleSplitCellVertically(selectedCell) {
+    const action = new SplitCellVerticallyAction();
+    selectedCell.apply(action);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/table/table-extension.js

@@ -40,6 +40,8 @@ import { ToggleHeaderTableColumnStrategy } from './action-handler-strategies/tog
 import { SELECT_TABLE_COLUMN } from './actions/select-table-column-action';
 import { SelectTableColumnStrategy } from './action-handler-strategies/select-table-column-strategy';
 import { PreventRowInsertInterceptor } from './action-handler-interceptors/prevent-row-insert-interceptor';
+import { MERGE_CELLS } from './actions/merge-cells-action';
+import { MergeCellsStrategy } from './action-handler-strategies/merge-cells-strategy';
 import { TableToTableBlockStrategy } from './element-to-dto-strategies/table-to-table-block-strategy';
 import { TheadToTableHeadBlockStrategy } from './element-to-dto-strategies/thead-to-table-head-block-strategy';
 import { TbodyToTableBodyBlockStrategy } from './element-to-dto-strategies/tbody-to-table-body-block-strategy';
@@ -55,6 +57,11 @@ import { RTE_TABLE_DEFAULT_COLORS } from './constants/styles.constants';
 import { UpdateTableCellPropertiesStrategy } from './action-handler-strategies/update-table-cell-properties-strategy';
 import { RTETableCellAnnotationsAction } from './actions/table-cell-annotations-action';
 import { RTETableHeadCellAnnotationsAction } from './actions/table-head-cell-annotations-action';
+import { RTETableColorManager } from './utils/table-color-manager';
+import { SPLIT_CELL_HORIZONTALLY } from './actions/split-cell-horizontally-action';
+import { SplitCellHorizontallyStrategy } from './action-handler-strategies/split-cell-horizontally-strategy';
+import { SPLIT_CELL_VERTICALLY } from './actions/split-cell-vertically-action';
+import { SplitCellVerticallyStrategy } from './action-handler-strategies/split-cell-vertically-strategy';
 /**
  * Function extension class for Vega Rich Text Editor.
  */
@@ -62,7 +69,7 @@ export 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 = RTE_TABLE_DEFAULT_COLORS) {
     super();
@@ -72,6 +79,7 @@ export class VegaRTETableExtension extends VegaRTEExtension {
     this.tableCellRenderer = new RTETableCellRenderer();
     this.tableHeadCellRenderer = new RTETableHeadCellRenderer();
     this.tableSelection = new RTETableSelection();
+    RTETableColorManager.setTableColors(colors);
     this.registerToolbarButtonRenderer('table', this.toolbarButtonRenderer);
     this.registerBlockBasicStrategies(RTETableBlock.name);
     this.registerBlockBasicStrategies(RTETableHeadBlock.name);
@@ -103,7 +111,6 @@ export class VegaRTETableExtension extends VegaRTEExtension {
     this.registerAnnotationHandler(new TableAnnotationHandler());
     this.registerAnnotationHandler(new TableCellAnnotationHandler());
     this.registerAnnotationHandler(new TableHeadCellAnnotationHandler());
-    this.tableBlockRenderer.updateTableColorSchema(colors);
   }
   /**
    * Initializes the extension with the given context
@@ -141,7 +148,12 @@ export class VegaRTETableExtension extends VegaRTEExtension {
   VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.name, INSERT_TABLE_COLUMN, new InsertTableColumnStrategy());
   VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.name, DELETE_TABLE_COLUMN, new DeleteTableColumnStrategy());
   VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.name, TOGGLE_HEADER_TABLE_COLUMN, new ToggleHeaderTableColumnStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableCellBlock.name, SPLIT_CELL_HORIZONTALLY, new SplitCellHorizontallyStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableCellBlock.name, SPLIT_CELL_VERTICALLY, new SplitCellVerticallyStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableHeadCellBlock.name, SPLIT_CELL_HORIZONTALLY, new SplitCellHorizontallyStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableHeadCellBlock.name, SPLIT_CELL_VERTICALLY, new SplitCellVerticallyStrategy());
   VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.name, SELECT_TABLE_COLUMN, new SelectTableColumnStrategy());
+  VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.name, MERGE_CELLS, new MergeCellsStrategy());
   VegaRTEExtension.registerActionHandleStrategy(RTETableBlock.name, UpdateTablePropertiesAction.name, new UpdateTablePropertiesStrategy());
   VegaRTEExtension.registerActionHandleStrategy(RTETableCellBlock.name, RTETableCellAnnotationsAction.name, new UpdateTableCellPropertiesStrategy());
   VegaRTEExtension.registerActionHandleStrategy(RTETableHeadCellBlock.name, RTETableHeadCellAnnotationsAction.name, new UpdateTableCellPropertiesStrategy());

package/dist/collection/components/vega-rich-text-editor/extensions/table/table-selection.js

@@ -10,6 +10,7 @@ import { isNonNullable } from '../../../../types/type-guard';
 import changeManager from '../../../../helpers/change-manager/change-manager';
 import DomNodeSubjectFactory from '../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-factory';
 import { VegaInternalRTEExtensionTableCellSelectionChange } from '../../../../helpers/event-manager/event-id/vega-internal-event-id';
+import { CommonAnnotationTypeEnum } from '../../dto/annotations/common-annotation.abstract';
 /**
  * Table selection helper used for mouse drag selection of cells.
  */
@@ -120,25 +121,113 @@ export class RTETableSelection {
     tableChildren.forEach((section) => {
       section.children.forEach((row) => allRows.push(row));
     });
-    const anchorRowIndex = allRows.indexOf(anchorRow);
-    const focusRowIndex = allRows.indexOf(focusRow);
-    const startRow = Math.min(anchorRowIndex, focusRowIndex);
-    const endRow = Math.max(anchorRowIndex, focusRowIndex);
-    const anchorColIndex = anchorRow.children.indexOf(anchor);
-    const focusColIndex = focusRow.children.indexOf(focus);
-    const startCol = Math.min(anchorColIndex, focusColIndex);
-    const endCol = Math.max(anchorColIndex, focusColIndex);
-    const result = [];
+    const { grid, cellMeta } = RTETableSelection.buildCellGrid(allRows);
+    const anchorMeta = cellMeta.get(anchor);
+    const focusMeta = cellMeta.get(focus);
+    if (!anchorMeta || !focusMeta) {
+      return [];
+    }
+    const anchorStartRow = anchorMeta.row;
+    const anchorEndRow = anchorMeta.row + anchorMeta.rowSpan - 1;
+    const anchorStartCol = anchorMeta.col;
+    const anchorEndCol = anchorMeta.col + anchorMeta.colSpan - 1;
+    const focusStartRow = focusMeta.row;
+    const focusEndRow = focusMeta.row + focusMeta.rowSpan - 1;
+    const focusStartCol = focusMeta.col;
+    const focusEndCol = focusMeta.col + focusMeta.colSpan - 1;
+    const startRow = Math.min(anchorStartRow, focusStartRow);
+    const endRow = Math.max(anchorEndRow, focusEndRow);
+    const startCol = Math.min(anchorStartCol, focusStartCol);
+    const endCol = Math.max(anchorEndCol, focusEndCol);
+    const result = new Set();
     for (let r = startRow; r <= endRow; r++) {
-      const row = allRows[r];
+      const row = grid[r];
       for (let c = startCol; c <= endCol; c++) {
-        const cell = row.children[c];
+        const cell = row[c];
         if (cell) {
-          result.push(cell);
+          result.add(cell);
+        }
+      }
+    }
+    return Array.from(result);
+  }
+  /**
+   * 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.
+   */
+  static getCellSpan(cell) {
+    let rowSpan = 1;
+    let colSpan = 1;
+    // First, try to get from customAttribute annotation (this works even without DOM)
+    const customAttr = cell.getAnnotationByType(CommonAnnotationTypeEnum.CUSTOM_ATTRIBUTE);
+    if (customAttr && customAttr.customAttribute) {
+      const attrs = customAttr.customAttribute;
+      if (attrs.rowSpan) {
+        rowSpan = parseInt(attrs.rowSpan, 10);
+      }
+      if (attrs.colSpan) {
+        colSpan = parseInt(attrs.colSpan, 10);
+      }
+    }
+    // Fallback to DOM attributes if annotation didn't have the values
+    if (rowSpan === 1 && colSpan === 1) {
+      const cellDOMElement = stateEntityRenderingRegistry.getDOMByEntity(cell);
+      if (cellDOMElement) {
+        const rowSpanAttr = cellDOMElement.getAttribute('rowSpan');
+        const colSpanAttr = cellDOMElement.getAttribute('colSpan');
+        if (rowSpanAttr) {
+          rowSpan = parseInt(rowSpanAttr, 10);
+        }
+        if (colSpanAttr) {
+          colSpan = parseInt(colSpanAttr, 10);
+        }
+      }
+    }
+    return {
+      rowSpan: Number.isFinite(rowSpan) && rowSpan > 0 ? rowSpan : 1,
+      colSpan: Number.isFinite(colSpan) && colSpan > 0 ? colSpan : 1,
+    };
+  }
+  /**
+   * 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.
+   */
+  static buildCellGrid(allRows) {
+    const grid = [];
+    const cellMeta = new Map();
+    for (let r = 0; r < allRows.length; r++) {
+      const row = allRows[r];
+      if (!grid[r]) {
+        grid[r] = [];
+      }
+      let col = 0;
+      for (let c = 0; c < row.children.length; c++) {
+        const cell = row.children[c];
+        // Find the next available column (skip cells occupied by rowSpan from previous rows)
+        while (grid[r][col]) {
+          col += 1;
+        }
+        const { rowSpan, colSpan } = RTETableSelection.getCellSpan(cell);
+        cellMeta.set(cell, { row: r, col, rowSpan, colSpan });
+        // Fill the grid for all positions this cell occupies
+        for (let rowOffset = 0; rowOffset < rowSpan; rowOffset++) {
+          const targetRow = r + rowOffset;
+          if (!grid[targetRow]) {
+            grid[targetRow] = [];
+          }
+          for (let colOffset = 0; colOffset < colSpan; colOffset++) {
+            grid[targetRow][col + colOffset] = cell;
+          }
         }
+        col += colSpan;
       }
     }
-    return result;
+    return { grid, cellMeta };
   }
   /**
    * Clean up event listeners.

package/dist/collection/components/vega-rich-text-editor/extensions/table/utils/table-color-manager.js

@@ -0,0 +1,51 @@
+import { VegaThemeManager } from '../../../../../helpers/theme/theme-manager';
+import { rgbToHex } from '../../../../../utils/ui';
+import { RTE_TABLE_DEFAULT_COLORS } from '../constants/styles.constants';
+/**
+ * Manages table colors for the rich text editor.
+ */
+export class RTETableColorManager {
+  /**
+   * Get the list of table colors.
+   *
+   * @returns {VegaRTEColorSchema[]} - Array of table colors.
+   */
+  static getTableColors() {
+    return RTETableColorManager.TABLE_COLORS;
+  }
+  /**
+   * Set the list of table colors.
+   *
+   * @param {VegaRTEColorSchema[]} colors - Array of table colors.
+   */
+  static setTableColors(colors) {
+    RTETableColorManager.TABLE_COLORS = colors;
+  }
+  /**
+   * Get color key from color value
+   *
+   * @param {string} colorValue - color value
+   * @returns {string} - color key
+   */
+  static getColorKey(colorValue) {
+    var _a;
+    let result = null;
+    const tableColors = RTETableColorManager.TABLE_COLORS;
+    if (tableColors) {
+      const hexColor = (_a = rgbToHex(colorValue)) === null || _a === void 0 ? void 0 : _a.toUpperCase();
+      if (hexColor) {
+        result = tableColors.find((schema) => VegaThemeManager.isDarkMode() ? schema.dark === hexColor : schema.light === hexColor);
+      }
+      else {
+        for (const color of tableColors) {
+          if (color.key === colorValue) {
+            result = color;
+            break;
+          }
+        }
+      }
+    }
+    return result ? result.key : '';
+  }
+}
+RTETableColorManager.TABLE_COLORS = RTE_TABLE_DEFAULT_COLORS;