@atlaskit/editor-plugin-table 0.0.0 → 0.0.1

package/dist/cjs/plugins/table/event-handlers.js

@@ -0,0 +1,441 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleMouseOver = exports.handleMouseOut = exports.handleMouseMove = exports.handleMouseLeave = exports.handleMouseDown = exports.handleFocus = exports.handleCut = exports.handleClick = exports.handleBlur = void 0;
+exports.handleTripleClick = handleTripleClick;
+exports.whenTableInFocus = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _prosemirrorState = require("prosemirror-state");
+
+var _cellSelection = require("@atlaskit/editor-tables/cell-selection");
+
+var _tableMap = require("@atlaskit/editor-tables/table-map");
+
+var _utils = require("@atlaskit/editor-tables/utils");
+
+var _utils2 = require("@atlaskit/editor-common/utils");
+
+var _analytics = require("@atlaskit/editor-common/analytics");
+
+var _commands = require("./commands");
+
+var _pluginFactory = require("./pm-plugins/plugin-factory");
+
+var _pluginFactory2 = require("./pm-plugins/table-resizing/plugin-factory");
+
+var _transforms = require("./transforms");
+
+var _types = require("./types");
+
+var _utils3 = require("./utils");
+
+var _getAllowAddColumnCustomStep = require("./utils/get-allow-add-column-custom-step");
+
+// import {
+//   isElementInTableCell,
+//   isLastItemMediaGroup,
+//   setNodeSelection,
+// } from '@atlaskit/editor-core/src/utils';
+// import { closestElement } from '@atlaskit/editor-core/src/utils/dom';
+var isFocusingCalendar = function isFocusingCalendar(event) {
+  return event instanceof FocusEvent && event.relatedTarget instanceof HTMLElement && event.relatedTarget.getAttribute('aria-label') === 'calendar';
+};
+
+var isFocusingModal = function isFocusingModal(event) {
+  return event instanceof FocusEvent && event.relatedTarget instanceof HTMLElement && event.relatedTarget.closest('[role="dialog"]');
+};
+
+var handleBlur = function handleBlur(view, event) {
+  var state = view.state,
+      dispatch = view.dispatch; // IE version check for ED-4665
+  // Calendar focus check for ED-10466
+
+  if (_utils2.browser.ie_version !== 11 && !isFocusingCalendar(event) && !isFocusingModal(event)) {
+    (0, _commands.setEditorFocus)(false)(state, dispatch);
+  }
+
+  event.preventDefault();
+  return false;
+};
+
+exports.handleBlur = handleBlur;
+
+var handleFocus = function handleFocus(view, event) {
+  var state = view.state,
+      dispatch = view.dispatch;
+  (0, _commands.setEditorFocus)(true)(state, dispatch);
+  event.preventDefault();
+  return false;
+};
+
+exports.handleFocus = handleFocus;
+
+var handleClick = function handleClick(view, event) {
+  if (!(event.target instanceof HTMLElement)) {
+    return false;
+  }
+
+  var element = event.target;
+  var table = (0, _utils.findTable)(view.state.selection);
+
+  if (event instanceof MouseEvent && (0, _utils3.isColumnControlsDecorations)(element)) {
+    var _getColumnOrRowIndex = (0, _utils3.getColumnOrRowIndex)(element),
+        _getColumnOrRowIndex2 = (0, _slicedToArray2.default)(_getColumnOrRowIndex, 1),
+        startIndex = _getColumnOrRowIndex2[0];
+
+    var state = view.state,
+        _dispatch = view.dispatch;
+    return (0, _commands.selectColumn)(startIndex, event.shiftKey)(state, _dispatch);
+  }
+
+  var matchfn = element.matches ? element.matches : element.msMatchesSelector; // check if the table cell with an image is clicked and its not the image itself
+
+  if (!table || !(0, _utils2.isElementInTableCell)(element) || !matchfn || matchfn.call(element, 'table .image, table p, table .image div')) {
+    return false;
+  }
+
+  var map = _tableMap.TableMap.get(table.node);
+  /** Getting the offset of current item clicked */
+
+
+  var colElement = (0, _utils2.closestElement)(element, 'td') || (0, _utils2.closestElement)(element, 'th');
+  var colIndex = colElement && colElement.cellIndex;
+  var rowElement = (0, _utils2.closestElement)(element, 'tr');
+  var rowIndex = rowElement && rowElement.rowIndex;
+  var cellIndex = map.width * rowIndex + colIndex;
+  var dispatch = view.dispatch,
+      _view$state = view.state,
+      tr = _view$state.tr,
+      paragraph = _view$state.schema.nodes.paragraph;
+  var editorElement = table.node.nodeAt(map.map[cellIndex]);
+  /** Only if the last item is media group, insert a paragraph */
+
+  if ((0, _utils2.isLastItemMediaGroup)(editorElement)) {
+    var posInTable = map.map[cellIndex] + editorElement.nodeSize;
+    tr.insert(posInTable + table.pos, paragraph.create());
+    dispatch(tr);
+    (0, _utils2.setNodeSelection)(view, posInTable + table.pos);
+  }
+
+  return true;
+};
+
+exports.handleClick = handleClick;
+
+var handleMouseOver = function handleMouseOver(view, mouseEvent) {
+  if (!(mouseEvent.target instanceof HTMLElement)) {
+    return false;
+  }
+
+  var state = view.state,
+      dispatch = view.dispatch;
+  var target = mouseEvent.target;
+
+  var _getPluginState = (0, _pluginFactory.getPluginState)(state),
+      insertColumnButtonIndex = _getPluginState.insertColumnButtonIndex,
+      insertRowButtonIndex = _getPluginState.insertRowButtonIndex;
+
+  if ((0, _utils3.isInsertRowButton)(target)) {
+    var _getColumnOrRowIndex3 = (0, _utils3.getColumnOrRowIndex)(target),
+        _getColumnOrRowIndex4 = (0, _slicedToArray2.default)(_getColumnOrRowIndex3, 2),
+        startIndex = _getColumnOrRowIndex4[0],
+        endIndex = _getColumnOrRowIndex4[1];
+
+    var positionRow = (0, _utils3.getMousePositionVerticalRelativeByElement)(mouseEvent) === 'bottom' ? endIndex : startIndex;
+    return (0, _commands.showInsertRowButton)(positionRow)(state, dispatch);
+  }
+
+  if ((0, _utils3.isColumnControlsDecorations)(target)) {
+    var _getColumnOrRowIndex5 = (0, _utils3.getColumnOrRowIndex)(target),
+        _getColumnOrRowIndex6 = (0, _slicedToArray2.default)(_getColumnOrRowIndex5, 1),
+        _startIndex = _getColumnOrRowIndex6[0];
+
+    var _state = view.state,
+        _dispatch2 = view.dispatch;
+    return (0, _commands.hoverColumns)([_startIndex], false)(_state, _dispatch2);
+  }
+
+  if (((0, _utils3.isCell)(target) || (0, _utils3.isCornerButton)(target)) && (typeof insertColumnButtonIndex === 'number' || typeof insertRowButtonIndex === 'number')) {
+    return (0, _commands.hideInsertColumnOrRowButton)()(state, dispatch);
+  }
+
+  if ((0, _utils3.isResizeHandleDecoration)(target)) {
+    var _getColumnOrRowIndex7 = (0, _utils3.getColumnOrRowIndex)(target),
+        _getColumnOrRowIndex8 = (0, _slicedToArray2.default)(_getColumnOrRowIndex7, 2),
+        _startIndex2 = _getColumnOrRowIndex8[0],
+        _endIndex = _getColumnOrRowIndex8[1];
+
+    return (0, _commands.showResizeHandleLine)({
+      left: _startIndex2,
+      right: _endIndex
+    })(state, dispatch);
+  }
+
+  return false;
+}; // Ignore any `mousedown` `event` from control and numbered column buttons
+// PM end up changing selection during shift selection if not prevented
+
+
+exports.handleMouseOver = handleMouseOver;
+
+var handleMouseDown = function handleMouseDown(_, event) {
+  var isControl = !!(event.target && event.target instanceof HTMLElement && ((0, _utils3.isTableContainerOrWrapper)(event.target) || (0, _utils3.isColumnControlsDecorations)(event.target) || (0, _utils3.isRowControlsButton)(event.target)));
+
+  if (isControl) {
+    event.preventDefault();
+  }
+
+  return isControl;
+};
+
+exports.handleMouseDown = handleMouseDown;
+
+var handleMouseOut = function handleMouseOut(view, mouseEvent) {
+  if (!(mouseEvent instanceof MouseEvent) || !(mouseEvent.target instanceof HTMLElement)) {
+    return false;
+  }
+
+  var target = mouseEvent.target;
+
+  if ((0, _utils3.isColumnControlsDecorations)(target)) {
+    var state = view.state,
+        dispatch = view.dispatch;
+    return (0, _commands.clearHoverSelection)()(state, dispatch);
+  }
+
+  var relatedTarget = mouseEvent.relatedTarget; // In case the user is moving between cell at the same column
+  // we don't need to hide the resize handle decoration
+
+  if ((0, _utils3.isResizeHandleDecoration)(target) && !(0, _utils3.isResizeHandleDecoration)(relatedTarget)) {
+    var _state2 = view.state,
+        _dispatch3 = view.dispatch;
+    return (0, _commands.hideResizeHandleLine)()(_state2, _dispatch3);
+  }
+
+  return false;
+};
+
+exports.handleMouseOut = handleMouseOut;
+
+var handleMouseLeave = function handleMouseLeave(view, event) {
+  if (!(event.target instanceof HTMLElement)) {
+    return false;
+  }
+
+  var state = view.state,
+      dispatch = view.dispatch;
+
+  var _getPluginState2 = (0, _pluginFactory.getPluginState)(state),
+      insertColumnButtonIndex = _getPluginState2.insertColumnButtonIndex,
+      insertRowButtonIndex = _getPluginState2.insertRowButtonIndex;
+
+  var target = event.target;
+
+  if ((0, _utils3.isTableControlsButton)(target)) {
+    return true;
+  }
+
+  if ((typeof insertColumnButtonIndex !== 'undefined' || typeof insertRowButtonIndex !== 'undefined') && (0, _commands.hideInsertColumnOrRowButton)()(state, dispatch)) {
+    return true;
+  }
+
+  return false;
+};
+
+exports.handleMouseLeave = handleMouseLeave;
+
+var handleMouseMove = function handleMouseMove(getEditorFeatureFlags) {
+  return function (view, event, tableCellOptimization, elementContentRects) {
+    if (!(event.target instanceof HTMLElement)) {
+      return false;
+    }
+
+    var element = event.target;
+
+    if ((0, _utils3.isColumnControlsDecorations)(element)) {
+      var state = view.state,
+          dispatch = view.dispatch;
+
+      var _getPluginState3 = (0, _pluginFactory.getPluginState)(state),
+          insertColumnButtonIndex = _getPluginState3.insertColumnButtonIndex;
+
+      var _getColumnOrRowIndex9 = (0, _utils3.getColumnOrRowIndex)(element),
+          _getColumnOrRowIndex10 = (0, _slicedToArray2.default)(_getColumnOrRowIndex9, 2),
+          startIndex = _getColumnOrRowIndex10[0],
+          endIndex = _getColumnOrRowIndex10[1];
+
+      var positionColumn = (0, _utils3.getMousePositionHorizontalRelativeByElement)(event, tableCellOptimization, elementContentRects) === 'right' ? endIndex : startIndex;
+
+      if (positionColumn !== insertColumnButtonIndex) {
+        return (0, _commands.showInsertColumnButton)(positionColumn)(state, dispatch);
+      }
+    }
+
+    if ((0, _utils3.isRowControlsButton)(element)) {
+      var _state3 = view.state,
+          _dispatch4 = view.dispatch;
+
+      var _getPluginState4 = (0, _pluginFactory.getPluginState)(_state3),
+          insertRowButtonIndex = _getPluginState4.insertRowButtonIndex;
+
+      var _getColumnOrRowIndex11 = (0, _utils3.getColumnOrRowIndex)(element),
+          _getColumnOrRowIndex12 = (0, _slicedToArray2.default)(_getColumnOrRowIndex11, 2),
+          _startIndex3 = _getColumnOrRowIndex12[0],
+          _endIndex2 = _getColumnOrRowIndex12[1];
+
+      var positionRow = (0, _utils3.getMousePositionVerticalRelativeByElement)(event) === 'bottom' ? _endIndex2 : _startIndex3;
+
+      if (positionRow !== insertRowButtonIndex) {
+        return (0, _commands.showInsertRowButton)(positionRow)(_state3, _dispatch4);
+      }
+    }
+
+    var _getEditorFeatureFlag = getEditorFeatureFlags(),
+        mouseMoveOptimization = _getEditorFeatureFlag.mouseMoveOptimization; // we only want to allow mouseMoveOptimisation when tableCellOptimization is enabled
+    // because it relies on tableCell node view that is added  via tableCellOptimization
+
+
+    var useMouseMoveOptimisation = tableCellOptimization && mouseMoveOptimization;
+
+    if (!(0, _utils3.isResizeHandleDecoration)(element) && (0, _utils3.isCell)(element)) {
+      var positionColumn = (0, _utils3.getMousePositionHorizontalRelativeByElement)(event, useMouseMoveOptimisation, elementContentRects, _types.RESIZE_HANDLE_AREA_DECORATION_GAP);
+
+      if (positionColumn !== null) {
+        var _state4 = view.state,
+            _dispatch5 = view.dispatch;
+
+        var _getPluginState5 = (0, _pluginFactory.getPluginState)(_state4),
+            resizeHandleColumnIndex = _getPluginState5.resizeHandleColumnIndex;
+
+        var tableCell = (0, _utils2.closestElement)(element, 'td, th');
+        var cellStartPosition = view.posAtDOM(tableCell, 0);
+        var rect = (0, _utils.findCellRectClosestToPos)(_state4.doc.resolve(cellStartPosition));
+
+        if (rect) {
+          var columnEndIndexTarget = positionColumn === 'left' ? rect.left : rect.right;
+
+          if (columnEndIndexTarget !== resizeHandleColumnIndex || !(0, _utils3.hasResizeHandler)({
+            target: element,
+            columnEndIndexTarget: columnEndIndexTarget
+          })) {
+            return (0, _commands.addResizeHandleDecorations)(columnEndIndexTarget)(_state4, _dispatch5);
+          }
+        }
+      }
+    }
+
+    return false;
+  };
+};
+
+exports.handleMouseMove = handleMouseMove;
+
+function handleTripleClick(view, pos) {
+  var state = view.state,
+      dispatch = view.dispatch;
+  var $cellPos = (0, _utils.cellAround)(state.doc.resolve(pos));
+
+  if (!$cellPos) {
+    return false;
+  }
+
+  var cell = state.doc.nodeAt($cellPos.pos);
+
+  if (cell) {
+    var selFrom = _prosemirrorState.Selection.findFrom($cellPos, 1, true);
+
+    var selTo = _prosemirrorState.Selection.findFrom(state.doc.resolve($cellPos.pos + cell.nodeSize), -1, true);
+
+    if (selFrom && selTo) {
+      dispatch(state.tr.setSelection(new _prosemirrorState.TextSelection(selFrom.$from, selTo.$to)));
+      return true;
+    }
+  }
+
+  return false;
+}
+
+var handleCut = function handleCut(oldTr, oldState, newState, editorAnalyticsAPI) {
+  var oldSelection = oldState.tr.selection;
+  var tr = newState.tr;
+
+  if (oldSelection instanceof _cellSelection.CellSelection) {
+    var $anchorCell = oldTr.doc.resolve(oldTr.mapping.map(oldSelection.$anchorCell.pos));
+    var $headCell = oldTr.doc.resolve(oldTr.mapping.map(oldSelection.$headCell.pos));
+    var cellSelection = new _cellSelection.CellSelection($anchorCell, $headCell);
+    tr.setSelection(cellSelection);
+
+    if (tr.selection instanceof _cellSelection.CellSelection) {
+      var rect = (0, _utils.getSelectionRect)(cellSelection);
+
+      if (rect) {
+        var _getSelectedCellInfo = (0, _utils3.getSelectedCellInfo)(tr.selection),
+            verticalCells = _getSelectedCellInfo.verticalCells,
+            horizontalCells = _getSelectedCellInfo.horizontalCells,
+            totalCells = _getSelectedCellInfo.totalCells,
+            totalRowCount = _getSelectedCellInfo.totalRowCount,
+            totalColumnCount = _getSelectedCellInfo.totalColumnCount; // Reassigning to make it more obvious and consistent
+
+
+        editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent({
+          action: _analytics.TABLE_ACTION.CUT,
+          actionSubject: _analytics.ACTION_SUBJECT.TABLE,
+          actionSubjectId: null,
+          attributes: {
+            verticalCells: verticalCells,
+            horizontalCells: horizontalCells,
+            totalCells: totalCells,
+            totalRowCount: totalRowCount,
+            totalColumnCount: totalColumnCount
+          },
+          eventType: _analytics.EVENT_TYPE.TRACK
+        })(tr); // Need this check again since we are overriding the tr in previous statement
+
+        if (tr.selection instanceof _cellSelection.CellSelection) {
+          var isTableSelected = tr.selection.isRowSelection() && tr.selection.isColSelection();
+
+          if (isTableSelected) {
+            tr = (0, _utils.removeTable)(tr);
+          } else if (tr.selection.isRowSelection()) {
+            var _getPluginState6 = (0, _pluginFactory.getPluginState)(newState),
+                isHeaderRowRequired = _getPluginState6.pluginConfig.isHeaderRowRequired;
+
+            tr = (0, _transforms.deleteRows)(rect, isHeaderRowRequired)(tr);
+          } else if (tr.selection.isColSelection()) {
+            tr = (0, _transforms.deleteColumns)(rect, (0, _getAllowAddColumnCustomStep.getAllowAddColumnCustomStep)(oldState))(tr);
+          }
+        }
+      }
+    }
+  }
+
+  return tr;
+};
+
+exports.handleCut = handleCut;
+
+var whenTableInFocus = function whenTableInFocus(eventHandler, elementContentRects) {
+  return function (view, mouseEvent) {
+    var _tablePluginState$plu;
+
+    var tableResizePluginState = (0, _pluginFactory2.getPluginState)(view.state);
+    var tablePluginState = (0, _pluginFactory.getPluginState)(view.state);
+    var isDragging = tableResizePluginState && !!tableResizePluginState.dragging;
+    var hasTableNode = tablePluginState && tablePluginState.tableNode;
+    var tableCellOptimization = tablePluginState === null || tablePluginState === void 0 ? void 0 : (_tablePluginState$plu = tablePluginState.pluginConfig) === null || _tablePluginState$plu === void 0 ? void 0 : _tablePluginState$plu.tableCellOptimization;
+
+    if (!hasTableNode || isDragging) {
+      return false;
+    }
+
+    return eventHandler(view, mouseEvent, tableCellOptimization, elementContentRects);
+  };
+};
+
+exports.whenTableInFocus = whenTableInFocus;

package/dist/cjs/plugins/table/handlers.js

@@ -0,0 +1,155 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleDocOrSelectionChanged = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _prosemirrorUtils = require("prosemirror-utils");
+
+var _utils = require("@atlaskit/editor-tables/utils");
+
+var _utils2 = require("@atlaskit/editor-common/utils");
+
+var _collapse = require("./utils/collapse");
+
+var _defaultTableSelection = require("./pm-plugins/default-table-selection");
+
+var _tableResizing = require("./pm-plugins/table-resizing");
+
+var _steps = require("@atlaskit/adf-schema/steps");
+
+var _nodes = require("./utils/nodes");
+
+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) { (0, _defineProperty2.default)(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; }
+
+var nextTableSorting = function nextTableSorting(tr, table) {
+  var tableSortStep = tr.steps.find(function (step) {
+    return step instanceof _steps.TableSortStep;
+  });
+  return tableSortStep && table && table.pos === tableSortStep.pos ? tableSortStep.next : undefined;
+};
+
+var nextResizeHandleColumnIndex = function nextResizeHandleColumnIndex(tr, resizeHandleColumnIndex) {
+  if (tr.getMeta(_tableResizing.pluginKey)) {
+    return undefined;
+  }
+
+  return resizeHandleColumnIndex;
+};
+
+var updateTargetCellPosition = function updateTargetCellPosition(_ref) {
+  var tr = _ref.tr,
+      table = _ref.table;
+  return function (pluginState) {
+    var tableNode = table && table.node;
+
+    if (!tableNode) {
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        targetCellPosition: undefined
+      });
+    }
+
+    var _tr$doc$type$schema$n = tr.doc.type.schema.nodes,
+        tableCell = _tr$doc$type$schema$n.tableCell,
+        tableHeader = _tr$doc$type$schema$n.tableHeader;
+    var cell = (0, _prosemirrorUtils.findParentNodeOfType)([tableCell, tableHeader])(tr.selection);
+    var targetCellPosition = cell ? cell.pos : undefined;
+
+    if (pluginState.targetCellPosition === targetCellPosition) {
+      return pluginState;
+    }
+
+    return _objectSpread(_objectSpread({}, pluginState), {}, {
+      targetCellPosition: targetCellPosition
+    });
+  };
+};
+
+var updateTableNodePluginState = function updateTableNodePluginState(_ref2) {
+  var tr = _ref2.tr,
+      table = _ref2.table;
+  return function (pluginState) {
+    var tableNode = table && table.node;
+
+    if (!tableNode || (0, _utils2.isTextInput)(tr)) {
+      return pluginState;
+    }
+
+    return _objectSpread(_objectSpread(_objectSpread({}, pluginState), _defaultTableSelection.defaultTableSelection), {}, {
+      tableNode: tableNode,
+      ordering: nextTableSorting(tr, table),
+      resizeHandleColumnIndex: nextResizeHandleColumnIndex(tr, pluginState.resizeHandleColumnIndex),
+      isNumberColumnEnabled: (0, _nodes.checkIfNumberColumnEnabled)(tr.selection),
+      isHeaderColumnEnabled: (0, _nodes.checkIfHeaderColumnEnabled)(tr.selection),
+      isHeaderRowEnabled: (0, _nodes.checkIfHeaderRowEnabled)(tr.selection)
+    });
+  };
+};
+
+var updateCollapseHandler = function updateCollapseHandler(_ref3) {
+  var tr = _ref3.tr,
+      table = _ref3.table;
+  return function (pluginState) {
+    var tableNode = table && table.node;
+    var schema = tr.doc.type.schema;
+    var allowCollapse = pluginState.pluginConfig.allowCollapse;
+    var isExpandInSchema = schema.nodes.expand !== undefined;
+    var isCollapseEnabled = allowCollapse && isExpandInSchema;
+    /**
+     * If we don't have focus, or collapse isn't allowed, or a table node doesn't
+     * exist, we don't need to waste extra checks below
+     */
+
+    if (!pluginState.editorHasFocus || !isCollapseEnabled || !tableNode) {
+      return pluginState;
+    }
+
+    var expandNodeType = schema.nodes.expand;
+    var isTableCollapsed = expandNodeType && !!(0, _prosemirrorUtils.findParentNodeOfType)(expandNodeType)(tr.selection);
+    var trCanBeCollapsed = (0, _collapse.isTableCollapsible)(tr).tableIsCollapsible; // We're focused on a table + we're not inside an expand
+
+    var canCollapseTable = !!pluginState.tableNode && // is it already collapsed?
+    !isTableCollapsed && !!trCanBeCollapsed;
+
+    if (pluginState.isTableCollapsed !== isTableCollapsed || pluginState.canCollapseTable !== canCollapseTable) {
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        isTableCollapsed: isTableCollapsed,
+        canCollapseTable: canCollapseTable
+      });
+    }
+
+    return pluginState;
+  };
+};
+
+var buildPluginState = function buildPluginState(builders) {
+  return function (props) {
+    return function (pluginState) {
+      if (!props.table) {
+        return pluginState.targetCellPosition ? _objectSpread(_objectSpread({}, pluginState), {}, {
+          targetCellPosition: undefined
+        }) : pluginState;
+      }
+
+      return builders.reduce(function (_pluginState, transform) {
+        return transform(props)(_pluginState);
+      }, pluginState);
+    };
+  };
+};
+
+var handleDocOrSelectionChanged = function handleDocOrSelectionChanged(tr, pluginState) {
+  return buildPluginState([updateTargetCellPosition, updateTableNodePluginState, updateCollapseHandler])({
+    tr: tr,
+    table: (0, _utils.findTable)(tr.selection)
+  })(pluginState);
+};
+
+exports.handleDocOrSelectionChanged = handleDocOrSelectionChanged;