@atlaskit/editor-plugin-table 0.0.0 → 0.0.2

package/dist/esm/plugins/table/commands/misc.js

@@ -0,0 +1,427 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+// #region Imports
+import { Selection, TextSelection } from 'prosemirror-state';
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
+import { selectionCell, findCellClosestToPos, findTable, getCellsInColumn, getCellsInRow, getSelectionRect, isSelectionType, removeTable, selectColumn as selectColumnTransform, selectRow as selectRowTransform, setCellAttrs, isTableSelected } from '@atlaskit/editor-tables/utils';
+import { isParagraph, isTextSelection, closestElement, mapSlice } from '@atlaskit/editor-common/utils';
+import { getDecorations } from '../pm-plugins/decorations/plugin';
+import { buildColumnResizingDecorations } from '../pm-plugins/decorations/utils';
+import { createCommand, getPluginState } from '../pm-plugins/plugin-factory';
+import { fixAutoSizedTable } from '../transforms';
+import { TableCssClassName as ClassName, TableDecorations } from '../types';
+import { createColumnControlsDecoration, createColumnSelectedDecoration } from '../utils/decoration';
+import { checkIfNumberColumnEnabled, checkIfHeaderColumnEnabled, checkIfHeaderRowEnabled, isIsolating } from '../utils/nodes';
+import { updatePluginStateDecorations } from '../utils/update-plugin-state-decorations'; // #endregion
+// #endregion
+// #region Commands
+
+export var setEditorFocus = function setEditorFocus(editorHasFocus) {
+  return createCommand({
+    type: 'SET_EDITOR_FOCUS',
+    data: {
+      editorHasFocus: editorHasFocus
+    }
+  });
+};
+export var setTableRef = function setTableRef(ref) {
+  return createCommand(function (state) {
+    var tableRef = ref;
+    var foundTable = findTable(state.selection);
+    var tableNode = ref && foundTable ? foundTable.node : undefined;
+    var tablePos = ref && foundTable ? foundTable.pos : undefined;
+    var tableWrapperTarget = closestElement(tableRef, ".".concat(ClassName.TABLE_NODE_WRAPPER)) || undefined;
+    var layout = tableNode ? tableNode.attrs.layout : undefined;
+    var decorationSet = updatePluginStateDecorations(state, createColumnControlsDecoration(state.selection), TableDecorations.COLUMN_CONTROLS_DECORATIONS);
+    return {
+      type: 'SET_TABLE_REF',
+      data: {
+        tableRef: tableRef,
+        tableNode: tableNode,
+        tablePos: tablePos,
+        tableWrapperTarget: tableWrapperTarget,
+        layout: layout || 'default',
+        isNumberColumnEnabled: checkIfNumberColumnEnabled(state.selection),
+        isHeaderRowEnabled: checkIfHeaderRowEnabled(state.selection),
+        isHeaderColumnEnabled: checkIfHeaderColumnEnabled(state.selection),
+        decorationSet: decorationSet,
+        resizeHandleColumnIndex: undefined
+      }
+    };
+  }, function (tr) {
+    return tr.setMeta('addToHistory', false);
+  });
+};
+export var setCellAttr = function setCellAttr(name, value) {
+  return function (state, dispatch) {
+    var tr = state.tr,
+        selection = state.selection;
+
+    if (selection instanceof CellSelection) {
+      var updated = false;
+      selection.forEachCell(function (cell, pos) {
+        if (cell.attrs[name] !== value) {
+          tr.setNodeMarkup(pos, cell.type, _objectSpread(_objectSpread({}, cell.attrs), {}, _defineProperty({}, name, value)));
+          updated = true;
+        }
+      });
+
+      if (updated) {
+        if (dispatch) {
+          dispatch(tr);
+        }
+
+        return true;
+      }
+    } else {
+      var cell = selectionCell(state.selection);
+
+      if (cell) {
+        if (dispatch) {
+          var _cell$nodeAfter, _cell$nodeAfter2;
+
+          dispatch(tr.setNodeMarkup(cell.pos, (_cell$nodeAfter = cell.nodeAfter) === null || _cell$nodeAfter === void 0 ? void 0 : _cell$nodeAfter.type, _objectSpread(_objectSpread({}, (_cell$nodeAfter2 = cell.nodeAfter) === null || _cell$nodeAfter2 === void 0 ? void 0 : _cell$nodeAfter2.attrs), {}, _defineProperty({}, name, value))));
+        }
+
+        return true;
+      }
+    }
+
+    return false;
+  };
+};
+export var triggerUnlessTableHeader = function triggerUnlessTableHeader(command) {
+  return function (state, dispatch, view) {
+    var selection = state.selection,
+        tableHeader = state.schema.nodes.tableHeader;
+
+    if (selection instanceof TextSelection) {
+      var cell = findCellClosestToPos(selection.$from);
+
+      if (cell && cell.node.type !== tableHeader) {
+        return command(state, dispatch, view);
+      }
+    }
+
+    if (selection instanceof CellSelection) {
+      var rect = getSelectionRect(selection);
+
+      if (!checkIfHeaderRowEnabled(selection) || rect && rect.top > 0) {
+        return command(state, dispatch, view);
+      }
+    }
+
+    return false;
+  };
+};
+export var transformSliceRemoveCellBackgroundColor = function transformSliceRemoveCellBackgroundColor(slice, schema) {
+  var _schema$nodes = schema.nodes,
+      tableCell = _schema$nodes.tableCell,
+      tableHeader = _schema$nodes.tableHeader;
+  return mapSlice(slice, function (maybeCell) {
+    if (maybeCell.type === tableCell || maybeCell.type === tableHeader) {
+      var cellAttrs = _objectSpread({}, maybeCell.attrs);
+
+      cellAttrs.background = undefined;
+      return maybeCell.type.createChecked(cellAttrs, maybeCell.content, maybeCell.marks);
+    }
+
+    return maybeCell;
+  });
+};
+export var transformSliceToAddTableHeaders = function transformSliceToAddTableHeaders(slice, schema) {
+  var _schema$nodes2 = schema.nodes,
+      table = _schema$nodes2.table,
+      tableHeader = _schema$nodes2.tableHeader,
+      tableRow = _schema$nodes2.tableRow;
+  return mapSlice(slice, function (maybeTable) {
+    if (maybeTable.type === table) {
+      var firstRow = maybeTable.firstChild;
+
+      if (firstRow) {
+        var headerCols = [];
+        firstRow.forEach(function (oldCol) {
+          headerCols.push(tableHeader.createChecked(oldCol.attrs, oldCol.content, oldCol.marks));
+        });
+        var headerRow = tableRow.createChecked(firstRow.attrs, headerCols, firstRow.marks);
+        return maybeTable.copy(maybeTable.content.replaceChild(0, headerRow));
+      }
+    }
+
+    return maybeTable;
+  });
+};
+export var transformSliceToRemoveColumnsWidths = function transformSliceToRemoveColumnsWidths(slice, schema) {
+  var _schema$nodes3 = schema.nodes,
+      tableHeader = _schema$nodes3.tableHeader,
+      tableCell = _schema$nodes3.tableCell;
+  return mapSlice(slice, function (maybeCell) {
+    if (maybeCell.type === tableCell || maybeCell.type === tableHeader) {
+      if (!maybeCell.attrs.colwidth) {
+        return maybeCell;
+      }
+
+      return maybeCell.type.createChecked(_objectSpread(_objectSpread({}, maybeCell.attrs), {}, {
+        colwidth: undefined
+      }), maybeCell.content, maybeCell.marks);
+    }
+
+    return maybeCell;
+  });
+};
+export var deleteTable = function deleteTable(state, dispatch) {
+  if (dispatch) {
+    dispatch(removeTable(state.tr));
+  }
+
+  return true;
+};
+export var deleteTableIfSelected = function deleteTableIfSelected(state, dispatch) {
+  if (isTableSelected(state.selection)) {
+    return deleteTable(state, dispatch);
+  }
+
+  return false;
+};
+export var convertFirstRowToHeader = function convertFirstRowToHeader(schema) {
+  return function (tr) {
+    var table = findTable(tr.selection);
+    var map = TableMap.get(table.node);
+
+    for (var i = 0; i < map.width; i++) {
+      var cell = table.node.child(0).child(i);
+      tr.setNodeMarkup(table.start + map.map[i], schema.nodes.tableHeader, cell.attrs);
+    }
+
+    return tr;
+  };
+};
+export var moveCursorBackward = function moveCursorBackward(state, dispatch) {
+  var _ref = state.selection,
+      $cursor = _ref.$cursor; // if cursor is in the middle of a text node, do nothing
+
+  if (!$cursor || $cursor.parentOffset > 0) {
+    return false;
+  } // find the node before the cursor
+
+
+  var before;
+  var cut;
+
+  if (!isIsolating($cursor.parent)) {
+    for (var i = $cursor.depth - 1; !before && i >= 0; i--) {
+      if ($cursor.index(i) > 0) {
+        cut = $cursor.before(i + 1);
+        before = $cursor.node(i).child($cursor.index(i) - 1);
+      }
+
+      if (isIsolating($cursor.node(i))) {
+        break;
+      }
+    }
+  } // if the node before is not a table node - do nothing
+
+
+  if (!before || before.type !== state.schema.nodes.table) {
+    return false;
+  }
+  /*
+    ensure we're just at a top level paragraph
+    otherwise, perform regular backspace behaviour
+   */
+
+
+  var grandparent = $cursor.node($cursor.depth - 1);
+
+  if ($cursor.parent.type !== state.schema.nodes.paragraph || grandparent && grandparent.type !== state.schema.nodes.doc) {
+    return false;
+  }
+
+  var tr = state.tr;
+  var lastCellPos = (cut || 0) - 4; // need to move cursor inside the table to be able to calculate table's offset
+
+  tr.setSelection(new TextSelection(state.doc.resolve(lastCellPos)));
+  var $from = tr.selection.$from;
+  var start = $from.start(-1);
+  var pos = start + $from.parent.nodeSize - 1; // move cursor to the last cell
+  // it doesn't join node before (last cell) with node after (content after the cursor)
+  // due to ridiculous amount of PM code that would have been required to overwrite
+
+  tr.setSelection(new TextSelection(state.doc.resolve(pos))); // if we are inside an empty paragraph not at the end of the doc we delete it
+
+  var cursorNode = $cursor.node();
+  var docEnd = state.doc.content.size;
+  var paragraphWrapStart = $cursor.pos - 1;
+  var paragraphWrapEnd = $cursor.pos + 1;
+
+  if (cursorNode.content.size === 0 && $cursor.pos + 1 !== docEnd) {
+    tr.delete(paragraphWrapStart, paragraphWrapEnd);
+  }
+
+  if (dispatch) {
+    dispatch(tr);
+  }
+
+  return true;
+};
+export var setMultipleCellAttrs = function setMultipleCellAttrs(attrs, targetCellPosition) {
+  return function (state, dispatch) {
+    var cursorPos;
+    var tr = state.tr;
+
+    if (isSelectionType(tr.selection, 'cell')) {
+      var selection = tr.selection;
+      selection.forEachCell(function (_cell, pos) {
+        var $pos = tr.doc.resolve(tr.mapping.map(pos + 1));
+        tr = setCellAttrs(findCellClosestToPos($pos), attrs)(tr);
+      });
+      cursorPos = selection.$headCell.pos;
+    } else if (targetCellPosition) {
+      var cell = findCellClosestToPos(tr.doc.resolve(targetCellPosition + 1));
+      tr = setCellAttrs(cell, attrs)(tr);
+      cursorPos = cell.pos;
+    }
+
+    if (tr.docChanged && cursorPos !== undefined) {
+      var $pos = tr.doc.resolve(tr.mapping.map(cursorPos));
+
+      if (dispatch) {
+        dispatch(tr.setSelection(Selection.near($pos)));
+      }
+
+      return true;
+    }
+
+    return false;
+  };
+};
+export var selectColumn = function selectColumn(column, expand) {
+  return createCommand(function (state) {
+    var cells = getCellsInColumn(column)(state.tr.selection);
+
+    if (!cells || !cells.length || typeof cells[0].pos !== 'number') {
+      return false;
+    }
+
+    var decorations = createColumnSelectedDecoration(selectColumnTransform(column, expand)(state.tr));
+    var decorationSet = updatePluginStateDecorations(state, decorations, TableDecorations.COLUMN_SELECTED);
+    var targetCellPosition = cells[0].pos;
+    return {
+      type: 'SELECT_COLUMN',
+      data: {
+        targetCellPosition: targetCellPosition,
+        decorationSet: decorationSet
+      }
+    };
+  }, function (tr) {
+    return selectColumnTransform(column, expand)(tr).setMeta('addToHistory', false);
+  });
+};
+export var selectRow = function selectRow(row, expand) {
+  return createCommand(function (state) {
+    var targetCellPosition;
+    var cells = getCellsInRow(row)(state.tr.selection);
+
+    if (cells && cells.length) {
+      targetCellPosition = cells[0].pos;
+    }
+
+    return {
+      type: 'SET_TARGET_CELL_POSITION',
+      data: {
+        targetCellPosition: targetCellPosition
+      }
+    };
+  }, function (tr) {
+    return selectRowTransform(row, expand)(tr).setMeta('addToHistory', false);
+  });
+};
+export var showInsertColumnButton = function showInsertColumnButton(columnIndex) {
+  return createCommand(function (_) {
+    return columnIndex > -1 ? {
+      type: 'SHOW_INSERT_COLUMN_BUTTON',
+      data: {
+        insertColumnButtonIndex: columnIndex
+      }
+    } : false;
+  }, function (tr) {
+    return tr.setMeta('addToHistory', false);
+  });
+};
+export var showInsertRowButton = function showInsertRowButton(rowIndex) {
+  return createCommand(function (_) {
+    return rowIndex > -1 ? {
+      type: 'SHOW_INSERT_ROW_BUTTON',
+      data: {
+        insertRowButtonIndex: rowIndex
+      }
+    } : false;
+  }, function (tr) {
+    return tr.setMeta('addToHistory', false);
+  });
+};
+export var hideInsertColumnOrRowButton = function hideInsertColumnOrRowButton() {
+  return createCommand({
+    type: 'HIDE_INSERT_COLUMN_OR_ROW_BUTTON'
+  }, function (tr) {
+    return tr.setMeta('addToHistory', false);
+  });
+};
+export var addResizeHandleDecorations = function addResizeHandleDecorations(columnIndex) {
+  return createCommand(function (state) {
+    var tableNode = findTable(state.selection);
+
+    var _getPluginState = getPluginState(state),
+        allowColumnResizing = _getPluginState.pluginConfig.allowColumnResizing;
+
+    if (!tableNode || !allowColumnResizing) {
+      return false;
+    }
+
+    return {
+      type: 'ADD_RESIZE_HANDLE_DECORATIONS',
+      data: {
+        decorationSet: buildColumnResizingDecorations(columnIndex)({
+          tr: state.tr,
+          decorationSet: getDecorations(state)
+        }),
+        resizeHandleColumnIndex: columnIndex
+      }
+    };
+  }, function (tr) {
+    return tr.setMeta('addToHistory', false);
+  });
+};
+export var autoSizeTable = function autoSizeTable(view, node, table, basePos, opts) {
+  view.dispatch(fixAutoSizedTable(view, node, table, basePos, opts));
+  return true;
+};
+export var addBoldInEmptyHeaderCells = function addBoldInEmptyHeaderCells(tableCellHeader) {
+  return function (state, dispatch) {
+    var tr = state.tr;
+
+    if ( // Avoid infinite loop when the current selection is not a TextSelection
+    isTextSelection(tr.selection) && tr.selection.$cursor && // When storedMark is null that means this is the initial state
+    // if the user press to remove the mark storedMark will be an empty array
+    // and we shouldn't apply the strong mark
+    tr.storedMarks == null && // Check if the current node is a direct child from paragraph
+    tr.selection.$from.depth === tableCellHeader.depth + 1 && // this logic is applied only for empty paragraph
+    tableCellHeader.node.nodeSize === 4 && isParagraph(tableCellHeader.node.firstChild, state.schema)) {
+      var strong = state.schema.marks.strong;
+      tr.setStoredMarks([strong.create()]).setMeta('addToHistory', false);
+
+      if (dispatch) {
+        dispatch(tr);
+      }
+
+      return true;
+    }
+
+    return false;
+  };
+}; // #endregion