opentiny 6.9.0 → 6.9.2

package/src/plugins/table/main/ts/ui/DomModifier.ts

@@ -1,40 +0,0 @@
-import Editor from 'tinymce/core/api/Editor';
-
-export interface DomModifier {
-  readonly setAttrib: (attr: string, value: string) => void;
-  readonly setStyle: (prop: string, value: string) => void;
-  readonly setFormat: (formatName: string, value: string) => void;
-}
-
-// The get node is required here because it can be transformed
-// when switching between tags (e.g. th and td)
-const normal = (editor: Editor, element: Element): DomModifier => {
-  const dom = editor.dom;
-
-  const setAttrib = (attr: string, value: string) => {
-    dom.setAttrib(element, attr, value);
-  };
-
-  const setStyle = (prop: string, value: string) => {
-    dom.setStyle(element, prop, value);
-  };
-
-  const setFormat = (formatName: string, value: string) => {
-    // Remove format if given an empty string
-    if (value === '') {
-      editor.formatter.remove(formatName, { value: null }, element, true);
-    } else {
-      editor.formatter.apply(formatName, { value }, element);
-    }
-  };
-
-  return {
-    setAttrib,
-    setStyle,
-    setFormat
-  };
-};
-
-export const DomModifier = {
-  normal
-};

package/src/plugins/table/main/ts/ui/Helpers.ts

@@ -1,243 +0,0 @@
-import { Transformations } from '@ephox/acid';
-import { Arr, Fun, Obj, Optional, Strings, Type } from '@ephox/katamari';
-import { TableLookup, TableOperations } from '@ephox/snooker';
-import { Css, SugarElement, SugarElements } from '@ephox/sugar';
-
-import DOMUtils from 'tinymce/core/api/dom/DOMUtils';
-import Editor from 'tinymce/core/api/Editor';
-
-import * as Styles from '../actions/Styles';
-import * as Options from '../api/Options';
-import * as Utils from '../core/Utils';
-
-/**
- * @class tinymce.table.ui.Helpers
- * @private
- */
-
-interface AdvancedStyles {
-  readonly borderwidth: string;
-  readonly borderstyle: string;
-  readonly bordercolor: string;
-  readonly backgroundcolor: string;
-}
-
-// Note: Need to use a types here, as types are iterable whereas interfaces are not
-// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-export type TableData = {
-  readonly height: string;
-  readonly width: string;
-  readonly cellspacing: string;
-  readonly cellpadding: string;
-  readonly caption: boolean;
-  readonly align: string;
-  readonly border: string;
-  class?: string;
-  cols?: string;
-  rows?: string;
-  borderstyle?: string;
-  bordercolor?: string;
-  backgroundcolor?: string;
-};
-
-// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-export type RowData = {
-  readonly height: string;
-  readonly class: string;
-  readonly align: string;
-  readonly type: string;
-  readonly borderstyle?: string;
-  readonly bordercolor?: string;
-  readonly backgroundcolor?: string;
-};
-
-// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-export type CellData = {
-  readonly width: string;
-  readonly scope: string;
-  readonly celltype: 'td' | 'th';
-  readonly class: string;
-  readonly halign: string;
-  readonly valign: string;
-  readonly borderwidth?: string;
-  readonly borderstyle?: string;
-  readonly bordercolor?: string;
-  readonly backgroundcolor?: string;
-};
-
-const rgbToHex = (value: string): string =>
-  Strings.startsWith(value, 'rgb') ? Transformations.rgbaToHexString(value) : value;
-
-const extractAdvancedStyles = (elm: Node): AdvancedStyles => {
-  const element = SugarElement.fromDom(elm);
-  return {
-    borderwidth: Css.getRaw(element, 'border-width').getOr(''),
-    borderstyle: Css.getRaw(element, 'border-style').getOr(''),
-    bordercolor: Css.getRaw(element, 'border-color').map(rgbToHex).getOr(''),
-    backgroundcolor: Css.getRaw(element, 'background-color').map(rgbToHex).getOr('')
-  };
-};
-
-const getSharedValues = <T extends Record<string, string>>(data: T[]): T => {
-  // TODO surely there's a better way to do this??
-  // Mutates baseData to return an object that contains only the values
-  // that were the same across all objects in data
-  const baseData: Record<string, string> = data[0];
-  const comparisonData = data.slice(1);
-
-  Arr.each(comparisonData, (items) => {
-    Arr.each(Obj.keys(baseData), (key) => {
-      Obj.each(items, (itemValue, itemKey) => {
-        const comparisonValue = baseData[key];
-        if (comparisonValue !== '' && key === itemKey) {
-          if (comparisonValue !== itemValue) {
-            baseData[key] = key === 'class' ? 'mce-no-match' : '';
-          }
-        }
-      });
-    });
-  });
-
-  return baseData as T;
-};
-
-// The extractDataFrom... functions are in this file partly for code reuse and partly so we can test them,
-// because some of these are crazy complicated
-
-const getAlignment = (formats: string[], formatName: string, editor: Editor, elm: Node): string =>
-  Arr.find(formats, (name) => !Type.isUndefined(editor.formatter.matchNode(elm, formatName + name))).getOr('');
-const getHAlignment = Fun.curry(getAlignment, [ 'left', 'center', 'right' ], 'align');
-const getVAlignment = Fun.curry(getAlignment, [ 'top', 'middle', 'bottom' ], 'valign');
-
-const extractDataFromSettings = (editor: Editor, hasAdvTableTab: boolean): TableData => {
-  const style = Options.getDefaultStyles(editor);
-  const attrs = Options.getDefaultAttributes(editor);
-
-  const extractAdvancedStyleData = () => ({
-    borderstyle: Obj.get(style, 'border-style').getOr(''),
-    bordercolor: rgbToHex(Obj.get(style, 'border-color').getOr('')),
-    backgroundcolor: rgbToHex(Obj.get(style, 'background-color').getOr(''))
-  });
-
-  const defaultData: TableData = {
-    height: '',
-    width: '100%',
-    cellspacing: '',
-    cellpadding: '',
-    caption: false,
-    class: '',
-    align: '',
-    border: ''
-  };
-
-  const getBorder = () => {
-    const borderWidth = style['border-width'];
-    if (Options.shouldStyleWithCss(editor) && borderWidth) {
-      return { border: borderWidth };
-    }
-    return Obj.get(attrs, 'border').fold(() => ({}), (border) => ({ border }));
-  };
-
-  const advStyle = (hasAdvTableTab ? extractAdvancedStyleData() : {});
-
-  const getCellPaddingCellSpacing = () => {
-    const spacing = Obj.get(style, 'border-spacing').or(Obj.get(attrs, 'cellspacing')).fold( () => ({}), (cellspacing) => ({ cellspacing }));
-    const padding = Obj.get(style, 'border-padding').or(Obj.get(attrs, 'cellpadding')).fold( () => ({}), (cellpadding) => ({ cellpadding }));
-    return {
-      ...spacing,
-      ...padding
-    };
-  };
-
-  const data = {
-    ...defaultData,
-    ...style,
-    ...attrs,
-    ...advStyle,
-    ...getBorder(),
-    ...getCellPaddingCellSpacing()
-  };
-  return data;
-};
-
-const getRowType = (elm: HTMLTableRowElement) =>
-  TableLookup.table(SugarElement.fromDom(elm)).map((table) => {
-    const target = { selection: SugarElements.fromDom(elm.cells) };
-    return TableOperations.getRowsType(table, target);
-  }).getOr('');
-
-const extractDataFromTableElement = (editor: Editor, elm: Element, hasAdvTableTab: boolean): TableData => {
-  const getBorder = (dom: DOMUtils, elm: Element) => {
-    // Cases (in order to check):
-    // 1. shouldStyleWithCss - extract border-width style if it exists
-    // 2. !shouldStyleWithCss && border attribute - set border attribute as value
-    // 3. !shouldStyleWithCss && nothing on the table - grab styles from the first th or td
-
-    const optBorderWidth = Css.getRaw(SugarElement.fromDom(elm), 'border-width');
-    if (Options.shouldStyleWithCss(editor) && optBorderWidth.isSome()) {
-      return optBorderWidth.getOr('');
-    }
-    return dom.getAttrib(elm, 'border') || Styles.getTDTHOverallStyle(editor.dom, elm, 'border-width')
-      || Styles.getTDTHOverallStyle(editor.dom, elm, 'border') || '';
-  };
-
-  const dom = editor.dom;
-
-  const cellspacing = Options.shouldStyleWithCss(editor) ?
-    dom.getStyle(elm, 'border-spacing') || dom.getAttrib(elm, 'cellspacing') :
-    dom.getAttrib(elm, 'cellspacing') || dom.getStyle(elm, 'border-spacing');
-
-  const cellpadding = Options.shouldStyleWithCss(editor) ?
-    Styles.getTDTHOverallStyle(dom, elm, 'padding') || dom.getAttrib(elm, 'cellpadding') :
-    dom.getAttrib(elm, 'cellpadding') || Styles.getTDTHOverallStyle(dom, elm, 'padding');
-
-  return {
-    width: dom.getStyle(elm, 'width') || dom.getAttrib(elm, 'width'),
-    height: dom.getStyle(elm, 'height') || dom.getAttrib(elm, 'height'),
-    cellspacing: cellspacing ?? '',
-    cellpadding: cellpadding ?? '',
-    border: getBorder(dom, elm),
-    caption: !!dom.select('caption', elm)[0],
-    class: dom.getAttrib(elm, 'class', ''),
-    align: getHAlignment(editor, elm),
-    ...(hasAdvTableTab ? extractAdvancedStyles(elm) : {})
-  };
-};
-
-const extractDataFromRowElement = (editor: Editor, elm: HTMLTableRowElement, hasAdvancedRowTab: boolean): RowData => {
-  const dom = editor.dom;
-  return {
-    height: dom.getStyle(elm, 'height') || dom.getAttrib(elm, 'height'),
-    class: dom.getAttrib(elm, 'class', ''),
-    type: getRowType(elm),
-    align: getHAlignment(editor, elm),
-    ...(hasAdvancedRowTab ? extractAdvancedStyles(elm) : {})
-  };
-};
-
-const extractDataFromCellElement = (editor: Editor, cell: HTMLTableCellElement, hasAdvancedCellTab: boolean, column: Optional<HTMLTableColElement>): CellData => {
-  const dom = editor.dom;
-  const colElm = column.getOr(cell);
-
-  const getStyle = (element: HTMLElement, style: string) => dom.getStyle(element, style) || dom.getAttrib(element, style);
-
-  return {
-    width: getStyle(colElm, 'width'),
-    scope: dom.getAttrib(cell, 'scope'),
-    celltype: Utils.getNodeName(cell) as 'td' | 'th',
-    class: dom.getAttrib(cell, 'class', ''),
-    halign: getHAlignment(editor, cell),
-    valign: getVAlignment(editor, cell),
-    ...(hasAdvancedCellTab ? extractAdvancedStyles(cell) : {})
-  };
-};
-
-export {
-  extractAdvancedStyles,
-  getSharedValues,
-  extractDataFromTableElement,
-  extractDataFromRowElement,
-  extractDataFromCellElement,
-  extractDataFromSettings
-};
-

package/src/plugins/table/main/ts/ui/MenuItems.ts

@@ -1,374 +0,0 @@
-import { Arr, Fun, Type } from '@ephox/katamari';
-import { SugarNode } from '@ephox/sugar';
-
-import Editor from 'tinymce/core/api/Editor';
-import { Menu } from 'tinymce/core/api/ui/Ui';
-
-import * as FakeClipboard from '../api/Clipboard';
-import * as Options from '../api/Options';
-import { SelectionTargets, LockedDisable } from '../selection/SelectionTargets';
-import { verticalAlignValues } from './CellAlignValues';
-import { applyTableCellStyle, changeColumnHeader, changeRowHeader, filterNoneItem, buildColorMenu, buildMenuItems } from './UiUtils';
-
-interface AddMenuSpec<T> {
-  readonly text: string;
-  readonly command: string;
-  readonly icon?: string;
-  readonly onSetup: (api: T) => () => void;
-  readonly onAction?: (api: T) => void;
-}
-
-const onSetupEditable = (editor: Editor) => (api: Menu.MenuItemInstanceApi): VoidFunction => {
-  const nodeChanged = () => {
-    api.setEnabled(editor.selection.isEditable());
-  };
-
-  editor.on('NodeChange', nodeChanged);
-  nodeChanged();
-
-  return () => {
-    editor.off('NodeChange', nodeChanged);
-  };
-};
-
-const addMenuItems = (editor: Editor, selectionTargets: SelectionTargets): void => {
-  const cmd = (command: string) => () => editor.execCommand(command);
-
-  // TODO: TINY-8172 Unwind this when an alternative solution is found
-  const addMenuIfRegistered = (name: string, spec: AddMenuSpec<Menu.MenuItemInstanceApi>) => {
-    if (editor.queryCommandSupported(spec.command)) {
-      editor.ui.registry.addMenuItem(name, {
-        ...spec,
-        onAction: Type.isFunction(spec.onAction) ? spec.onAction : cmd(spec.command)
-      });
-      return true;
-    } else {
-      return false;
-    }
-  };
-
-  // TODO: TINY-8172 Unwind this when an alternative solution is found
-  const addToggleMenuIfRegistered = (name: string, spec: AddMenuSpec<Menu.ToggleMenuItemInstanceApi>) => {
-    if (editor.queryCommandSupported(spec.command)) {
-      editor.ui.registry.addToggleMenuItem(name, {
-        ...spec,
-        onAction: Type.isFunction(spec.onAction) ? spec.onAction : cmd(spec.command)
-      });
-    }
-  };
-
-  const insertTableAction = (data: { numRows: number; numColumns: number }) => {
-    editor.execCommand('mceInsertTable', false, {
-      rows: data.numRows,
-      columns: data.numColumns
-    });
-  };
-
-  const hasRowMenuItems = [
-    addMenuIfRegistered('tableinsertrowbefore', {
-      text: 'Insert row before',
-      icon: 'table-insert-row-above',
-      command: 'mceTableInsertRowBefore',
-      onSetup: selectionTargets.onSetupCellOrRow
-    }),
-    addMenuIfRegistered('tableinsertrowafter', {
-      text: 'Insert row after',
-      icon: 'table-insert-row-after',
-      command: 'mceTableInsertRowAfter',
-      onSetup: selectionTargets.onSetupCellOrRow
-    }),
-    addMenuIfRegistered('tabledeleterow', {
-      text: 'Delete row',
-      icon: 'table-delete-row',
-      command: 'mceTableDeleteRow',
-      onSetup: selectionTargets.onSetupCellOrRow
-    }),
-    addMenuIfRegistered('tablerowprops', {
-      text: 'Row properties',
-      icon: 'table-row-properties',
-      command: 'mceTableRowProps',
-      onSetup: selectionTargets.onSetupCellOrRow
-    }),
-
-    addMenuIfRegistered('tablecutrow', {
-      text: 'Cut row',
-      icon: 'cut-row',
-      command: 'mceTableCutRow',
-      onSetup: selectionTargets.onSetupCellOrRow
-    }),
-    addMenuIfRegistered('tablecopyrow', {
-      text: 'Copy row',
-      icon: 'duplicate-row',
-      command: 'mceTableCopyRow',
-      onSetup: selectionTargets.onSetupCellOrRow
-    }),
-    addMenuIfRegistered('tablepasterowbefore', {
-      text: 'Paste row before',
-      icon: 'paste-row-before',
-      command: 'mceTablePasteRowBefore',
-      onSetup: selectionTargets.onSetupPasteable(FakeClipboard.getRows)
-    }),
-    addMenuIfRegistered('tablepasterowafter', {
-      text: 'Paste row after',
-      icon: 'paste-row-after',
-      command: 'mceTablePasteRowAfter',
-      onSetup: selectionTargets.onSetupPasteable(FakeClipboard.getRows)
-    }),
-  ];
-
-  const hasColumnMenuItems = [
-    addMenuIfRegistered('tableinsertcolumnbefore', {
-      text: 'Insert column before',
-      icon: 'table-insert-column-before',
-      command: 'mceTableInsertColBefore',
-      onSetup: selectionTargets.onSetupColumn(LockedDisable.onFirst)
-    }),
-    addMenuIfRegistered('tableinsertcolumnafter', {
-      text: 'Insert column after',
-      icon: 'table-insert-column-after',
-      command: 'mceTableInsertColAfter',
-      onSetup: selectionTargets.onSetupColumn(LockedDisable.onLast)
-    }),
-    addMenuIfRegistered('tabledeletecolumn', {
-      text: 'Delete column',
-      icon: 'table-delete-column',
-      command: 'mceTableDeleteCol',
-      onSetup: selectionTargets.onSetupColumn(LockedDisable.onAny)
-    }),
-
-    addMenuIfRegistered('tablecutcolumn', {
-      text: 'Cut column',
-      icon: 'cut-column',
-      command: 'mceTableCutCol',
-      onSetup: selectionTargets.onSetupColumn(LockedDisable.onAny)
-    }),
-    addMenuIfRegistered('tablecopycolumn', {
-      text: 'Copy column',
-      icon: 'duplicate-column',
-      command: 'mceTableCopyCol',
-      onSetup: selectionTargets.onSetupColumn(LockedDisable.onAny)
-    }),
-    addMenuIfRegistered('tablepastecolumnbefore', {
-      text: 'Paste column before',
-      icon: 'paste-column-before',
-      command: 'mceTablePasteColBefore',
-      onSetup: selectionTargets.onSetupPasteableColumn(FakeClipboard.getColumns, LockedDisable.onFirst)
-    }),
-    addMenuIfRegistered('tablepastecolumnafter', {
-      text: 'Paste column after',
-      icon: 'paste-column-after',
-      command: 'mceTablePasteColAfter',
-      onSetup: selectionTargets.onSetupPasteableColumn(FakeClipboard.getColumns, LockedDisable.onLast)
-    }),
-  ];
-
-  const hasCellMenuItems = [
-    addMenuIfRegistered('tablecellprops', {
-      text: 'Cell properties',
-      icon: 'table-cell-properties',
-      command: 'mceTableCellProps',
-      onSetup: selectionTargets.onSetupCellOrRow
-    }),
-    addMenuIfRegistered('tablemergecells', {
-      text: 'Merge cells',
-      icon: 'table-merge-cells',
-      command: 'mceTableMergeCells',
-      onSetup: selectionTargets.onSetupMergeable
-    }),
-    addMenuIfRegistered('tablesplitcells', {
-      text: 'Split cell',
-      icon: 'table-split-cells',
-      command: 'mceTableSplitCells',
-      onSetup: selectionTargets.onSetupUnmergeable
-    }),
-  ];
-
-  if (!Options.hasTableGrid(editor)) {
-    editor.ui.registry.addMenuItem('inserttable', {
-      text: 'Table',
-      icon: 'table',
-      onAction: cmd('mceInsertTableDialog'),
-      onSetup: onSetupEditable(editor)
-    });
-  } else {
-    editor.ui.registry.addNestedMenuItem('inserttable', {
-      text: 'Table',
-      icon: 'table',
-      getSubmenuItems: () => [{ type: 'fancymenuitem', fancytype: 'inserttable', onAction: insertTableAction }],
-      onSetup: onSetupEditable(editor)
-    });
-  }
-
-  // TINY-3636: We want a way to use the dialog even when tablegrid true.
-  // If tablegrid false then inserttable and inserttabledialog are the same,
-  // but that's preferrable to breaking things at this point.
-  editor.ui.registry.addMenuItem('inserttabledialog', {
-    text: 'Insert table',
-    icon: 'table',
-    onAction: cmd('mceInsertTableDialog'),
-    onSetup: onSetupEditable(editor)
-  });
-
-  addMenuIfRegistered('tableprops', {
-    text: 'Table properties',
-    onSetup: selectionTargets.onSetupTable,
-    command: 'mceTableProps'
-  });
-  addMenuIfRegistered('deletetable', {
-    text: 'Delete table',
-    icon: 'table-delete-table',
-    onSetup: selectionTargets.onSetupTable,
-    command: 'mceTableDelete'
-  });
-
-  // if any of the row menu items returned true
-  if (Arr.contains(hasRowMenuItems, true)) {
-    editor.ui.registry.addNestedMenuItem('row', {
-      type: 'nestedmenuitem',
-      text: 'Row',
-      getSubmenuItems: Fun.constant('tableinsertrowbefore tableinsertrowafter tabledeleterow tablerowprops | tablecutrow tablecopyrow tablepasterowbefore tablepasterowafter')
-    });
-  }
-
-  if (Arr.contains(hasColumnMenuItems, true)) {
-    editor.ui.registry.addNestedMenuItem('column', {
-      type: 'nestedmenuitem',
-      text: 'Column',
-      getSubmenuItems: Fun.constant('tableinsertcolumnbefore tableinsertcolumnafter tabledeletecolumn | tablecutcolumn tablecopycolumn tablepastecolumnbefore tablepastecolumnafter')
-    });
-  }
-
-  if (Arr.contains(hasCellMenuItems, true)) {
-    editor.ui.registry.addNestedMenuItem('cell', {
-      type: 'nestedmenuitem',
-      text: 'Cell',
-      getSubmenuItems: Fun.constant('tablecellprops tablemergecells tablesplitcells')
-    });
-  }
-
-  editor.ui.registry.addContextMenu('table', {
-    update: () => {
-      // context menu fires before node change, so check the selection here first
-      selectionTargets.resetTargets();
-      // ignoring element since it's monitored elsewhere
-      return selectionTargets.targets().fold(Fun.constant(''), (targets) => {
-        // If clicking in a caption, then we shouldn't show the cell/row/column options
-        if (SugarNode.name(targets.element) === 'caption') {
-          return 'tableprops deletetable';
-        } else {
-          return 'cell row column | advtablesort | tableprops deletetable';
-        }
-      });
-    }
-  });
-
-  const tableClassList = filterNoneItem(Options.getTableClassList(editor));
-  if (tableClassList.length !== 0 && editor.queryCommandSupported('mceTableToggleClass')) {
-    editor.ui.registry.addNestedMenuItem('tableclass', {
-      icon: 'table-classes',
-      text: 'Table styles',
-      getSubmenuItems: () => buildMenuItems(
-        editor,
-        tableClassList,
-        'tableclass',
-        (value) => editor.execCommand('mceTableToggleClass', false, value)
-      ),
-      onSetup: selectionTargets.onSetupTable
-    });
-  }
-
-  const tableCellClassList = filterNoneItem(Options.getCellClassList(editor));
-  if (tableCellClassList.length !== 0 && editor.queryCommandSupported('mceTableCellToggleClass')) {
-    editor.ui.registry.addNestedMenuItem('tablecellclass', {
-      icon: 'table-cell-classes',
-      text: 'Cell styles',
-      getSubmenuItems: () => buildMenuItems(
-        editor,
-        tableCellClassList,
-        'tablecellclass',
-        (value) => editor.execCommand('mceTableCellToggleClass', false, value)
-      ),
-      onSetup: selectionTargets.onSetupCellOrRow
-    });
-  }
-
-  // TODO: TINY-8172 Unwind this when an alternative solution is found
-  if (editor.queryCommandSupported('mceTableApplyCellStyle')) {
-    editor.ui.registry.addNestedMenuItem('tablecellvalign', {
-      icon: 'vertical-align',
-      text: 'Vertical align',
-      getSubmenuItems: () => buildMenuItems(
-        editor,
-        verticalAlignValues,
-        'tablecellverticalalign',
-        applyTableCellStyle(editor, 'vertical-align')
-      ),
-      onSetup: selectionTargets.onSetupCellOrRow
-    });
-
-    editor.ui.registry.addNestedMenuItem('tablecellborderwidth', {
-      icon: 'border-width',
-      text: 'Border width',
-      getSubmenuItems: () => buildMenuItems(
-        editor,
-        Options.getTableBorderWidths(editor),
-        'tablecellborderwidth',
-        applyTableCellStyle(editor, 'border-width')
-      ),
-      onSetup: selectionTargets.onSetupCellOrRow
-    });
-
-    editor.ui.registry.addNestedMenuItem('tablecellborderstyle', {
-      icon: 'border-style',
-      text: 'Border style',
-      getSubmenuItems: () => buildMenuItems(
-        editor,
-        Options.getTableBorderStyles(editor),
-        'tablecellborderstyle',
-        applyTableCellStyle(editor, 'border-style')
-      ),
-      onSetup: selectionTargets.onSetupCellOrRow
-    });
-
-    editor.ui.registry.addNestedMenuItem('tablecellbackgroundcolor', {
-      icon: 'cell-background-color',
-      text: 'Background color',
-      getSubmenuItems: () => buildColorMenu(editor, Options.getTableBackgroundColorMap(editor), 'background-color'),
-      onSetup: selectionTargets.onSetupCellOrRow
-    });
-
-    editor.ui.registry.addNestedMenuItem('tablecellbordercolor', {
-      icon: 'cell-border-color',
-      text: 'Border color',
-      getSubmenuItems: () => buildColorMenu(editor, Options.getTableBorderColorMap(editor), 'border-color'),
-      onSetup: selectionTargets.onSetupCellOrRow
-    });
-  }
-
-  addToggleMenuIfRegistered('tablecaption', {
-    icon: 'table-caption',
-    text: 'Table caption',
-    command: 'mceTableToggleCaption',
-    onSetup: selectionTargets.onSetupTableWithCaption
-  });
-
-  addToggleMenuIfRegistered('tablerowheader', {
-    text: 'Row header',
-    icon: 'table-top-header',
-    command: 'mceTableRowType',
-    onAction: changeRowHeader(editor),
-    onSetup: selectionTargets.onSetupTableRowHeaders
-  });
-
-  addToggleMenuIfRegistered('tablecolheader', {
-    text: 'Column header',
-    icon: 'table-left-header',
-    command: 'mceTableColType',
-    onAction: changeColumnHeader(editor),
-    onSetup: selectionTargets.onSetupTableRowHeaders
-  });
-};
-
-export {
-  addMenuItems
-};