opentiny 6.9.0 → 6.9.1

package/src/models/dom/main/ts/table/actions/InsertTable.ts

@@ -1,84 +0,0 @@
-import { Arr, Fun, Type } from '@ephox/katamari';
-import { TableRender, TableConversions } from '@ephox/snooker';
-import { Attribute, Html, SelectorFilter, SelectorFind, SugarElement } from '@ephox/sugar';
-
-import Editor from 'tinymce/core/api/Editor';
-
-import * as Events from '../api/Events';
-import * as Options from '../api/Options';
-import * as Utils from '../core/TableUtils';
-
-const placeCaretInCell = (editor: Editor, cell: SugarElement<HTMLTableCellElement>): void => {
-  editor.selection.select(cell.dom, true);
-  editor.selection.collapse(true);
-};
-
-const selectFirstCellInTable = (editor: Editor, tableElm: SugarElement<HTMLTableElement>): void => {
-  SelectorFind.descendant<HTMLTableCellElement>(tableElm, 'td,th').each(Fun.curry(placeCaretInCell, editor));
-};
-
-const fireEvents = (editor: Editor, table: SugarElement<HTMLTableElement>): void => {
-  Arr.each(SelectorFilter.descendants<HTMLTableRowElement>(table, 'tr'), (row) => {
-    Events.fireNewRow(editor, row.dom);
-
-    Arr.each(SelectorFilter.descendants<HTMLTableCellElement>(row, 'th,td'), (cell) => {
-      Events.fireNewCell(editor, cell.dom);
-    });
-  });
-};
-
-const isPercentage = (width: string): boolean =>
-  Type.isString(width) && width.indexOf('%') !== -1;
-
-const insert = (editor: Editor, columns: number, rows: number, colHeaders: number, rowHeaders: number): HTMLTableElement | null => {
-  const defaultStyles = Options.getTableDefaultStyles(editor);
-  const options: TableRender.RenderOptions = {
-    styles: defaultStyles,
-    attributes: Options.getTableDefaultAttributes(editor),
-    colGroups: Options.tableUseColumnGroup(editor)
-  };
-
-  // Don't create an undo level when inserting the base table HTML otherwise we can end up with 2 undo levels
-  editor.undoManager.ignore(() => {
-    const table = TableRender.render(rows, columns, rowHeaders, colHeaders, Options.getTableHeaderType(editor), options);
-    Attribute.set(table, 'data-mce-id', '__mce');
-
-    const html = Html.getOuter(table);
-    editor.insertContent(html);
-    editor.addVisual();
-  });
-
-  // Enforce the sizing mode of the table
-  return SelectorFind.descendant<HTMLTableElement>(Utils.getBody(editor), 'table[data-mce-id="__mce"]').map((table) => {
-    if (Options.isTablePixelsForced(editor)) {
-      TableConversions.convertToPixelSizeWidth(table);
-    } else if (Options.isTableResponsiveForced(editor)) {
-      TableConversions.convertToNoneSizeWidth(table);
-    } else if (Options.isTablePercentagesForced(editor) || isPercentage(defaultStyles.width)) {
-      TableConversions.convertToPercentSizeWidth(table);
-    }
-    Utils.removeDataStyle(table);
-    Attribute.remove(table, 'data-mce-id');
-    fireEvents(editor, table);
-    selectFirstCellInTable(editor, table);
-    return table.dom;
-  }).getOrNull();
-};
-
-const insertTable = (editor: Editor, rows: number, columns: number, options: Record<string, number> = {}): HTMLTableElement | null => {
-  const checkInput = (val: any) => Type.isNumber(val) && val > 0;
-
-  if (checkInput(rows) && checkInput(columns)) {
-    const headerRows = options.headerRows || 0;
-    const headerColumns = options.headerColumns || 0;
-    return insert(editor, columns, rows, headerColumns, headerRows);
-  } else {
-    // eslint-disable-next-line no-console
-    console.error('Invalid values for mceInsertTable - rows and columns values are required to insert a table.');
-    return null;
-  }
-};
-
-export {
-  insertTable
-};

package/src/models/dom/main/ts/table/actions/TableActions.ts

@@ -1,213 +0,0 @@
-import { Arr, Fun, Optional } from '@ephox/katamari';
-import { DomDescent } from '@ephox/phoenix';
-import {
-  CellMutations, ResizeBehaviour, RunOperation, TableFill, TableGridSize, TableSection, TableOperations, TableLookup
-} from '@ephox/snooker';
-import { Attribute, SugarBody, SugarElement, SugarNode } from '@ephox/sugar';
-
-import Editor from 'tinymce/core/api/Editor';
-import { TableEventData } from 'tinymce/core/api/EventTypes';
-
-import * as Events from '../api/Events';
-import * as Options from '../api/Options';
-import { TableCellSelectionHandler } from '../api/TableCellSelectionHandler';
-import { TableResizeHandler } from '../api/TableResizeHandler';
-import * as Utils from '../core/TableUtils';
-import * as TableSize from '../queries/TableSize';
-
-type TableAction<T> = (table: SugarElement<HTMLTableElement>, target: T, noEvents?: boolean) => Optional<TableActionResult>;
-export interface TableActionResult {
-  readonly rng: Range;
-  readonly effect: TableEventData;
-}
-export type CombinedTargetsTableAction = TableAction<RunOperation.CombinedTargets>;
-export type PasteTableAction = TableAction<RunOperation.TargetPaste>;
-export type AdvancedPasteTableAction = TableAction<RunOperation.TargetPasteRows>;
-export type LookupAction = (table: SugarElement<HTMLTableElement>, target: RunOperation.TargetSelection) => string;
-
-type GuardFn = (table: SugarElement<HTMLTableElement>) => boolean;
-type MutateFn = (e1: SugarElement<HTMLTableCellElement | HTMLTableColElement>, e2: SugarElement<HTMLTableCellElement | HTMLTableColElement>) => void;
-
-export interface TableActions {
-  readonly deleteRow: CombinedTargetsTableAction;
-  readonly deleteColumn: CombinedTargetsTableAction;
-  readonly insertRowsBefore: CombinedTargetsTableAction;
-  readonly insertRowsAfter: CombinedTargetsTableAction;
-  readonly insertColumnsBefore: CombinedTargetsTableAction;
-  readonly insertColumnsAfter: CombinedTargetsTableAction;
-  readonly mergeCells: CombinedTargetsTableAction;
-  readonly unmergeCells: CombinedTargetsTableAction;
-  readonly pasteCells: PasteTableAction;
-  readonly pasteColsBefore: AdvancedPasteTableAction;
-  readonly pasteColsAfter: AdvancedPasteTableAction;
-  readonly pasteRowsBefore: AdvancedPasteTableAction;
-  readonly pasteRowsAfter: AdvancedPasteTableAction;
-  readonly makeCellsHeader: CombinedTargetsTableAction;
-  readonly unmakeCellsHeader: CombinedTargetsTableAction;
-  readonly makeColumnsHeader: CombinedTargetsTableAction;
-  readonly unmakeColumnsHeader: CombinedTargetsTableAction;
-  readonly makeRowsHeader: CombinedTargetsTableAction;
-  readonly makeRowsBody: CombinedTargetsTableAction;
-  readonly makeRowsFooter: CombinedTargetsTableAction;
-  readonly getTableRowType: LookupAction;
-  readonly getTableCellType: LookupAction;
-  readonly getTableColType: LookupAction;
-}
-
-export const TableActions = (editor: Editor, resizeHandler: TableResizeHandler, cellSelectionHandler: TableCellSelectionHandler): TableActions => {
-  const isTableBody = (editor: Editor): boolean =>
-    SugarNode.name(Utils.getBody(editor)) === 'table';
-
-  const lastRowGuard = (table: SugarElement<HTMLTableElement>): boolean =>
-    !isTableBody(editor) || TableGridSize.getGridSize(table).rows > 1;
-
-  const lastColumnGuard = (table: SugarElement<HTMLTableElement>): boolean =>
-    !isTableBody(editor) || TableGridSize.getGridSize(table).columns > 1;
-
-  // Optional.none gives the default cloneFormats.
-  const cloneFormats = Options.getTableCloneElements(editor);
-
-  const colMutationOp = Options.isResizeTableColumnResizing(editor) ? Fun.noop : CellMutations.halve;
-
-  const getTableSectionType = (table: SugarElement<HTMLTableElement>) => {
-    switch (Options.getTableHeaderType(editor)) {
-      case 'section':
-        return TableSection.section();
-      case 'sectionCells':
-        return TableSection.sectionCells();
-      case 'cells':
-        return TableSection.cells();
-      default:
-        // Attempt to automatically find the type. If a type can't be found
-        // then fallback to "section" to maintain backwards compatibility.
-        return TableSection.getTableSectionType(table, 'section');
-    }
-  };
-
-  const setSelectionFromAction = (table: SugarElement<HTMLTableElement>, result: RunOperation.RunOperationOutput) =>
-    result.cursor.fold(() => {
-      // Snooker has reported we don't have a good cursor position. However, we may have a locked column
-      // with noneditable cells, so lets check if we have a noneditable cell and if so place the selection
-      const cells = TableLookup.cells(table);
-      return Arr.head(cells).filter(SugarBody.inBody).map((firstCell) => {
-        cellSelectionHandler.clearSelectedCells(table.dom);
-        const rng = editor.dom.createRng();
-        rng.selectNode(firstCell.dom);
-        editor.selection.setRng(rng);
-        Attribute.set(firstCell, 'data-mce-selected', '1');
-        return rng;
-      });
-    }, (cell) => {
-      const des = DomDescent.freefallRtl(cell);
-      const rng = editor.dom.createRng();
-      rng.setStart(des.element.dom, des.offset);
-      rng.setEnd(des.element.dom, des.offset);
-      editor.selection.setRng(rng);
-      cellSelectionHandler.clearSelectedCells(table.dom);
-      return Optional.some(rng);
-    });
-
-  const execute = <T> (operation: RunOperation.OperationCallback<T>, guard: GuardFn, mutate: MutateFn, effect: TableEventData) =>
-    (table: SugarElement<HTMLTableElement>, target: T, noEvents: boolean = false): Optional<TableActionResult> => {
-      Utils.removeDataStyle(table);
-      const doc = SugarElement.fromDom(editor.getDoc());
-      const generators = TableFill.cellOperations(mutate, doc, cloneFormats);
-      const behaviours: RunOperation.OperationBehaviours = {
-        sizing: TableSize.get(editor, table),
-        resize: Options.isResizeTableColumnResizing(editor) ? ResizeBehaviour.resizeTable() : ResizeBehaviour.preserveTable(),
-        section: getTableSectionType(table)
-      };
-      return guard(table) ? operation(table, target, generators, behaviours).bind((result) => {
-        // Update the resize bars after the table operation
-        resizeHandler.refresh(table.dom);
-
-        // INVESTIGATE: Should "noEvents" prevent these from firing as well?
-        Arr.each(result.newRows, (row) => {
-          Events.fireNewRow(editor, row.dom);
-        });
-        Arr.each(result.newCells, (cell) => {
-          Events.fireNewCell(editor, cell.dom);
-        });
-
-        const range = setSelectionFromAction(table, result);
-
-        if (SugarBody.inBody(table)) {
-          Utils.removeDataStyle(table);
-          if (!noEvents) {
-            Events.fireTableModified(editor, table.dom, effect);
-          }
-        }
-
-        return range.map((rng) => ({
-          rng,
-          effect
-        }));
-      }) : Optional.none<TableActionResult>();
-    };
-
-  const deleteRow = execute(TableOperations.eraseRows, lastRowGuard, Fun.noop, Events.structureModified);
-
-  const deleteColumn = execute(TableOperations.eraseColumns, lastColumnGuard, Fun.noop, Events.structureModified);
-
-  const insertRowsBefore = execute(TableOperations.insertRowsBefore, Fun.always, Fun.noop, Events.structureModified);
-
-  const insertRowsAfter = execute(TableOperations.insertRowsAfter, Fun.always, Fun.noop, Events.structureModified);
-
-  const insertColumnsBefore = execute(TableOperations.insertColumnsBefore, Fun.always, colMutationOp, Events.structureModified);
-
-  const insertColumnsAfter = execute(TableOperations.insertColumnsAfter, Fun.always, colMutationOp, Events.structureModified);
-
-  const mergeCells = execute(TableOperations.mergeCells, Fun.always, Fun.noop, Events.structureModified);
-
-  const unmergeCells = execute(TableOperations.unmergeCells, Fun.always, Fun.noop, Events.structureModified);
-
-  const pasteColsBefore = execute(TableOperations.pasteColsBefore, Fun.always, Fun.noop, Events.structureModified);
-
-  const pasteColsAfter = execute(TableOperations.pasteColsAfter, Fun.always, Fun.noop, Events.structureModified);
-
-  const pasteRowsBefore = execute(TableOperations.pasteRowsBefore, Fun.always, Fun.noop, Events.structureModified);
-
-  const pasteRowsAfter = execute(TableOperations.pasteRowsAfter, Fun.always, Fun.noop, Events.structureModified);
-
-  const pasteCells = execute(TableOperations.pasteCells, Fun.always, Fun.noop, Events.styleAndStructureModified);
-
-  const makeCellsHeader = execute(TableOperations.makeCellsHeader, Fun.always, Fun.noop, Events.structureModified);
-  const unmakeCellsHeader = execute(TableOperations.unmakeCellsHeader, Fun.always, Fun.noop, Events.structureModified);
-
-  const makeColumnsHeader = execute(TableOperations.makeColumnsHeader, Fun.always, Fun.noop, Events.structureModified);
-  const unmakeColumnsHeader = execute(TableOperations.unmakeColumnsHeader, Fun.always, Fun.noop, Events.structureModified);
-
-  const makeRowsHeader = execute(TableOperations.makeRowsHeader, Fun.always, Fun.noop, Events.structureModified);
-  const makeRowsBody = execute(TableOperations.makeRowsBody, Fun.always, Fun.noop, Events.structureModified);
-  const makeRowsFooter = execute(TableOperations.makeRowsFooter, Fun.always, Fun.noop, Events.structureModified);
-
-  const getTableCellType = TableOperations.getCellsType;
-  const getTableColType = TableOperations.getColumnsType;
-  const getTableRowType = TableOperations.getRowsType;
-
-  return {
-    deleteRow,
-    deleteColumn,
-    insertRowsBefore,
-    insertRowsAfter,
-    insertColumnsBefore,
-    insertColumnsAfter,
-    mergeCells,
-    unmergeCells,
-    pasteColsBefore,
-    pasteColsAfter,
-    pasteRowsBefore,
-    pasteRowsAfter,
-    pasteCells,
-    makeCellsHeader,
-    unmakeCellsHeader,
-    makeColumnsHeader,
-    unmakeColumnsHeader,
-    makeRowsHeader,
-    makeRowsBody,
-    makeRowsFooter,
-    getTableRowType,
-    getTableCellType,
-    getTableColType
-  };
-};

package/src/models/dom/main/ts/table/api/Clipboard.ts

@@ -1,67 +0,0 @@
-/*
- NOTE: This file is duplicated in the following locations:
-  - plugins/table/api/Clipboard.ts
- Make sure that if making changes to this file, the other files are updated as well
- */
-
-import { Arr, Optional } from '@ephox/katamari';
-import { SugarElement } from '@ephox/sugar';
-
-import FakeClipboard from 'tinymce/core/api/FakeClipboard';
-
-type RowElement = HTMLTableRowElement | HTMLTableColElement;
-
-const tableTypeBase = 'x-tinymce/dom-table-';
-const tableTypeRow = tableTypeBase + 'rows';
-const tableTypeColumn = tableTypeBase + 'columns';
-
-const setData = (items: Record<string, SugarElement<RowElement>[]>) => {
-  const fakeClipboardItem = FakeClipboard.FakeClipboardItem(items);
-  FakeClipboard.write([ fakeClipboardItem ]);
-};
-
-const getData = <T>(type: string): Optional<T[]> => {
-  const items = FakeClipboard.read() ?? [];
-  return Arr.findMap(items, (item) => Optional.from(item.getType<T[]>(type)));
-};
-
-const clearData = (type: string): void => {
-  if (getData(type).isSome()) {
-    FakeClipboard.clear();
-  }
-};
-
-const setRows = (rowsOpt: Optional<SugarElement<RowElement>[]>): void => {
-  rowsOpt.fold(
-    clearRows,
-    (rows) => setData({ [tableTypeRow]: rows })
-  );
-};
-
-const getRows = (): Optional<SugarElement<RowElement>[]> =>
-  getData(tableTypeRow);
-
-const clearRows = (): void =>
-  clearData(tableTypeRow);
-
-const setColumns = (columnsOpt: Optional<SugarElement<RowElement>[]>): void => {
-  columnsOpt.fold(
-    clearColumns,
-    (columns) => setData({ [tableTypeColumn]: columns })
-  );
-};
-
-const getColumns = (): Optional<SugarElement<RowElement>[]> =>
-  getData(tableTypeColumn);
-
-const clearColumns = (): void =>
-  clearData(tableTypeColumn);
-
-export {
-  setRows,
-  getRows,
-  clearRows,
-  setColumns,
-  getColumns,
-  clearColumns
-};

package/src/models/dom/main/ts/table/api/Commands.ts

@@ -1,253 +0,0 @@
-import { Arr, Fun, Obj, Optional, Type } from '@ephox/katamari';
-import { CopyCols, CopyRows, Sizes, TableFill, TableLookup, TableConversions } from '@ephox/snooker';
-import { Insert, Remove, Replication, SelectorFind, Selectors, SugarElement, SugarNode } from '@ephox/sugar';
-
-import Editor from 'tinymce/core/api/Editor';
-
-import * as InsertTable from '../actions/InsertTable';
-import { AdvancedPasteTableAction, CombinedTargetsTableAction, TableActionResult, TableActions } from '../actions/TableActions';
-import * as Events from '../api/Events';
-import * as Utils from '../core/TableUtils';
-import * as TableTargets from '../queries/TableTargets';
-import * as TableSelection from '../selection/TableSelection';
-import * as FakeClipboard from './Clipboard';
-import * as Options from './Options';
-
-type ExecuteAction<T> = (table: SugarElement<HTMLTableElement>, startCell: SugarElement<HTMLTableCellElement>) => T;
-
-interface InsertTableArgs {
-  readonly rows: number;
-  readonly columns: number;
-  readonly options?: Record<string, number>;
-}
-
-const getSelectionStartCellOrCaption = (editor: Editor): Optional<SugarElement<HTMLTableCellElement | HTMLTableCaptionElement>> =>
-  TableSelection.getSelectionCellOrCaption(Utils.getSelectionStart(editor), Utils.getIsRoot(editor)).filter(Utils.isInEditableContext);
-
-const getSelectionStartCell = (editor: Editor): Optional<SugarElement<HTMLTableCellElement>> =>
-  TableSelection.getSelectionCell(Utils.getSelectionStart(editor), Utils.getIsRoot(editor)).filter(Utils.isInEditableContext);
-
-const registerCommands = (editor: Editor, actions: TableActions): void => {
-  const isRoot = Utils.getIsRoot(editor);
-  const eraseTable = () => getSelectionStartCellOrCaption(editor).each((cellOrCaption) => {
-    TableLookup.table(cellOrCaption, isRoot).filter(Fun.not(isRoot)).each((table) => {
-      const cursor = SugarElement.fromText('');
-      Insert.after(table, cursor);
-      Remove.remove(table);
-
-      if (editor.dom.isEmpty(editor.getBody())) {
-        editor.setContent('');
-        editor.selection.setCursorLocation();
-      } else {
-        const rng = editor.dom.createRng();
-        rng.setStart(cursor.dom, 0);
-        rng.setEnd(cursor.dom, 0);
-        editor.selection.setRng(rng);
-        editor.nodeChanged();
-      }
-    });
-  });
-
-  const setSizingMode = (sizing: string) => getSelectionStartCellOrCaption(editor).each((cellOrCaption) => {
-    // Do nothing if tables are forced to use a specific sizing mode
-    const isForcedSizing = Options.isTableResponsiveForced(editor) || Options.isTablePixelsForced(editor) || Options.isTablePercentagesForced(editor);
-    if (!isForcedSizing) {
-      TableLookup.table(cellOrCaption, isRoot).each((table) => {
-        if (sizing === 'relative' && !Sizes.isPercentSizing(table)) {
-          TableConversions.convertToPercentSizeWidth(table);
-        } else if (sizing === 'fixed' && !Sizes.isPixelSizing(table)) {
-          TableConversions.convertToPixelSizeWidth(table);
-        } else if (sizing === 'responsive' && !Sizes.isNoneSizing(table)) {
-          TableConversions.convertToNoneSizeWidth(table);
-        }
-        Utils.removeDataStyle(table);
-        Events.fireTableModified(editor, table.dom, Events.structureModified);
-      });
-    }
-  });
-
-  const getTableFromCell = (cell: SugarElement<HTMLTableCellElement>) => TableLookup.table(cell, isRoot);
-
-  const performActionOnSelection = <T>(action: ExecuteAction<T>): Optional<T> =>
-    getSelectionStartCell(editor).bind((cell) =>
-      getTableFromCell(cell).map((table) => action(table, cell))
-    );
-
-  const toggleTableClass = (_ui: boolean, clazz: string) => {
-    performActionOnSelection((table) => {
-      editor.formatter.toggle('tableclass', { value: clazz }, table.dom);
-      Events.fireTableModified(editor, table.dom, Events.styleModified);
-    });
-  };
-
-  const toggleTableCellClass = (_ui: boolean, clazz: string) => {
-    performActionOnSelection((table) => {
-      const selectedCells = TableSelection.getCellsFromSelection(editor);
-      const allHaveClass = Arr.forall(selectedCells, (cell) => editor.formatter.match('tablecellclass', { value: clazz }, cell.dom));
-      const formatterAction = allHaveClass ? editor.formatter.remove : editor.formatter.apply;
-
-      Arr.each(selectedCells, (cell) =>
-        formatterAction('tablecellclass', { value: clazz }, cell.dom)
-      );
-      Events.fireTableModified(editor, table.dom, Events.styleModified);
-    });
-  };
-
-  const toggleCaption = () => {
-    getSelectionStartCellOrCaption(editor).each((cellOrCaption) => {
-      TableLookup.table(cellOrCaption, isRoot).each((table) => {
-        SelectorFind.child(table, 'caption').fold(
-          () => {
-            const caption = SugarElement.fromTag('caption');
-            Insert.append(caption, SugarElement.fromText('Caption'));
-            Insert.appendAt(table, caption, 0);
-            editor.selection.setCursorLocation(caption.dom, 0);
-          },
-          (caption) => {
-            if (SugarNode.isTag('caption')(cellOrCaption)) {
-              Selectors.one('td', table).each((td) =>
-                editor.selection.setCursorLocation(td.dom, 0)
-              );
-            }
-            Remove.remove(caption);
-          }
-        );
-
-        Events.fireTableModified(editor, table.dom, Events.structureModified);
-      });
-    });
-  };
-
-  const postExecute = (_data: TableActionResult): void => {
-    editor.focus();
-  };
-
-  const actOnSelection = (execute: CombinedTargetsTableAction, noEvents: boolean = false) =>
-    performActionOnSelection((table, startCell) => {
-      const targets = TableTargets.forMenu(TableSelection.getCellsFromSelection(editor), table, startCell);
-      execute(table, targets, noEvents).each(postExecute);
-    });
-
-  const copyRowSelection = () =>
-    performActionOnSelection((table, startCell) => {
-      const targets = TableTargets.forMenu(TableSelection.getCellsFromSelection(editor), table, startCell);
-      const generators = TableFill.cellOperations(Fun.noop, SugarElement.fromDom(editor.getDoc()), Optional.none());
-      return CopyRows.copyRows(table, targets, generators);
-    });
-
-  const copyColSelection = () =>
-    performActionOnSelection((table, startCell) => {
-      const targets = TableTargets.forMenu(TableSelection.getCellsFromSelection(editor), table, startCell);
-      return CopyCols.copyCols(table, targets);
-    });
-
-  const pasteOnSelection = (execute: AdvancedPasteTableAction, getRows: () => Optional<SugarElement<HTMLTableRowElement | HTMLTableColElement>[]>) =>
-    // If we have FakeClipboard rows to paste
-    getRows().each((rows) => {
-      const clonedRows = Arr.map(rows, (row) => Replication.deep<HTMLTableColElement | HTMLTableRowElement>(row));
-      performActionOnSelection((table, startCell) => {
-        const generators = TableFill.paste(SugarElement.fromDom(editor.getDoc()));
-        const targets = TableTargets.pasteRows(TableSelection.getCellsFromSelection(editor), startCell, clonedRows, generators);
-        execute(table, targets).each(postExecute);
-      });
-    });
-
-  const actOnType = (getAction: (type: string) => CombinedTargetsTableAction) => (_ui: boolean, args: Record<string, any>) =>
-    Obj.get(args, 'type').each((type) => {
-      actOnSelection(getAction(type), args.no_events);
-    });
-
-  // Register action commands
-  Obj.each({
-    mceTableSplitCells: () => actOnSelection(actions.unmergeCells),
-    mceTableMergeCells: () => actOnSelection(actions.mergeCells),
-    mceTableInsertRowBefore: () => actOnSelection(actions.insertRowsBefore),
-    mceTableInsertRowAfter: () => actOnSelection(actions.insertRowsAfter),
-    mceTableInsertColBefore: () => actOnSelection(actions.insertColumnsBefore),
-    mceTableInsertColAfter: () => actOnSelection(actions.insertColumnsAfter),
-    mceTableDeleteCol: () => actOnSelection(actions.deleteColumn),
-    mceTableDeleteRow: () => actOnSelection(actions.deleteRow),
-    mceTableCutCol: () => copyColSelection().each((selection) => {
-      FakeClipboard.setColumns(selection);
-      actOnSelection(actions.deleteColumn);
-    }),
-    mceTableCutRow: () => copyRowSelection().each((selection) => {
-      FakeClipboard.setRows(selection);
-      actOnSelection(actions.deleteRow);
-    }),
-    mceTableCopyCol: () => copyColSelection().each((selection) => FakeClipboard.setColumns(selection)),
-    mceTableCopyRow: () => copyRowSelection().each((selection) => FakeClipboard.setRows(selection)),
-    mceTablePasteColBefore: () => pasteOnSelection(actions.pasteColsBefore, FakeClipboard.getColumns),
-    mceTablePasteColAfter: () => pasteOnSelection(actions.pasteColsAfter, FakeClipboard.getColumns),
-    mceTablePasteRowBefore: () => pasteOnSelection(actions.pasteRowsBefore, FakeClipboard.getRows),
-    mceTablePasteRowAfter: () => pasteOnSelection(actions.pasteRowsAfter, FakeClipboard.getRows),
-    mceTableDelete: eraseTable,
-    mceTableCellToggleClass: toggleTableCellClass,
-    mceTableToggleClass: toggleTableClass,
-    mceTableToggleCaption: toggleCaption,
-    mceTableSizingMode: (_ui: boolean, sizing: string) => setSizingMode(sizing),
-    mceTableCellType: actOnType((type) => type === 'th' ? actions.makeCellsHeader : actions.unmakeCellsHeader),
-    mceTableColType: actOnType((type) => type === 'th' ? actions.makeColumnsHeader : actions.unmakeColumnsHeader),
-    mceTableRowType: actOnType((type) => {
-      switch (type) {
-        case 'header':
-          return actions.makeRowsHeader;
-        case 'footer':
-          return actions.makeRowsFooter;
-        default:
-          return actions.makeRowsBody;
-      }
-    })
-  }, (func, name) => editor.addCommand(name, func));
-
-  editor.addCommand('mceInsertTable', (_ui: boolean, args: InsertTableArgs) => {
-    InsertTable.insertTable(editor, args.rows, args.columns, args.options);
-  });
-
-  // Apply cell style using command (background color, border color, border style and border width)
-  // tinyMCE.activeEditor.execCommand('mceTableApplyCellStyle', false, { backgroundColor: 'red', borderColor: 'blue' })
-  // Remove cell style using command (an empty string indicates to remove the style)
-  // tinyMCE.activeEditor.execCommand('mceTableApplyCellStyle', false, { backgroundColor: '' })
-  editor.addCommand('mceTableApplyCellStyle', (_ui: boolean, args: Record<string, string>) => {
-    const getFormatName = (style: string) => 'tablecell' + style.toLowerCase().replace('-', '');
-
-    if (!Type.isObject(args)) {
-      return;
-    }
-    const cells = Arr.filter(TableSelection.getCellsFromSelection(editor), Utils.isInEditableContext);
-    if (cells.length === 0) {
-      return;
-    }
-
-    const validArgs = Obj.filter(args, (value, style) =>
-      editor.formatter.has(getFormatName(style)) && Type.isString(value)
-    );
-    if (Obj.isEmpty(validArgs)) {
-      return;
-    }
-
-    Obj.each(validArgs, (value, style) => {
-      const formatName = getFormatName(style);
-
-      Arr.each(cells, (cell) => {
-        if (value === '') {
-          editor.formatter.remove(formatName, { value: null }, cell.dom, true);
-        } else {
-          editor.formatter.apply(formatName, { value }, cell.dom);
-        }
-      });
-    });
-
-    /*
-      Use the first cell in the selection to get the table and fire the TableModified event.
-      If this command is applied over multiple tables, only the first table selected
-      will have a TableModified event thrown.
-    */
-    getTableFromCell(cells[0]).each(
-      (table) => Events.fireTableModified(editor, table.dom, Events.styleModified)
-    );
-  });
-
-};
-
-export { registerCommands };