@atlaskit/editor-plugin-table 0.0.0 → 0.0.1

package/dist/cjs/plugins/table/pm-plugins/table-resizing/utils/resize-state.js

@@ -0,0 +1,364 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateColgroup = exports.normaliseTableLayout = exports.getTotalWidth = exports.getResizeState = exports.getNewResizeStateFromSelectedColumns = exports.evenSelectedColumnsWidths = exports.evenAllColumnsWidths = exports.bulkColumnsResize = exports.areColumnsEven = exports.adjustColumnsWidths = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _styles = require("@atlaskit/editor-common/styles");
+
+var _utils = require("@atlaskit/editor-common/utils");
+
+var _colgroup = require("./colgroup");
+
+var _columnState = require("./column-state");
+
+var _dom = require("./dom");
+
+var _misc = require("./misc");
+
+var _utils2 = require("../../../utils");
+
+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 getResizeState = function getResizeState(_ref) {
+  var minWidth = _ref.minWidth,
+      maxSize = _ref.maxSize,
+      table = _ref.table,
+      tableRef = _ref.tableRef,
+      start = _ref.start,
+      domAtPos = _ref.domAtPos;
+
+  if ((0, _colgroup.hasTableBeenResized)(table)) {
+    var _cols = (0, _utils.calcTableColumnWidths)(table).map(function (width, index) {
+      return {
+        width: width === 0 ? _styles.tableNewColumnMinWidth : width,
+        minWidth: width === 0 ? _styles.tableNewColumnMinWidth : minWidth,
+        index: index
+      };
+    });
+
+    var _widths = _cols.map(function (col) {
+      return col.width;
+    });
+
+    var _tableWidth = _widths.reduce(function (sum, width) {
+      return sum + width;
+    }, 0);
+
+    var _overflow = _tableWidth > maxSize;
+
+    return {
+      cols: _cols,
+      widths: _widths,
+      maxSize: maxSize,
+      tableWidth: _tableWidth,
+      overflow: _overflow
+    };
+  } // Getting the resize state from DOM
+
+
+  var colgroupChildren = (0, _colgroup.insertColgroupFromNode)(tableRef, table);
+  var cols = Array.from(colgroupChildren).map(function (_, index) {
+    var cellsRefs = (0, _columnState.getCellsRefsInColumn)(index, table, start, domAtPos);
+    return (0, _columnState.getColumnStateFromDOM)(cellsRefs, index, minWidth);
+  });
+  var widths = cols.map(function (col) {
+    return col.width;
+  });
+  var tableWidth = widths.reduce(function (sum, width) {
+    return sum + width;
+  }, 0);
+  var overflow = tableWidth > maxSize;
+  return {
+    cols: cols,
+    widths: widths,
+    maxSize: maxSize,
+    tableWidth: tableWidth,
+    overflow: overflow
+  };
+}; // updates Colgroup DOM node with new widths
+
+
+exports.getResizeState = getResizeState;
+
+var updateColgroup = function updateColgroup(state, tableRef) {
+  var cols = tableRef.querySelectorAll('col');
+  state.cols.filter(function (column) {
+    return column && !!column.width;
+  }) // if width is 0, we dont want to apply that.
+  .forEach(function (column, i) {
+    if (cols[i]) {
+      cols[i].style.width = "".concat(column.width, "px");
+    }
+  }); // colgroup has updated, reflect new widths in sticky header
+
+  (0, _dom.syncStickyRowToTable)(tableRef);
+};
+
+exports.updateColgroup = updateColgroup;
+
+var getTotalWidth = function getTotalWidth(_ref2) {
+  var cols = _ref2.cols;
+  return cols.reduce(function (totalWidth, col) {
+    return totalWidth + col.width;
+  }, 0);
+}; // adjust columns to take up the total width
+// difference in total columns widths vs table width happens due to the "Math.floor"
+
+
+exports.getTotalWidth = getTotalWidth;
+
+var adjustColumnsWidths = function adjustColumnsWidths(resizeState, maxSize) {
+  var totalWidth = getTotalWidth(resizeState);
+  var diff = maxSize - totalWidth;
+
+  if (diff > 0 || diff < 0 && Math.abs(diff) < _styles.tableCellMinWidth) {
+    var updated = false;
+    return _objectSpread(_objectSpread({}, resizeState), {}, {
+      cols: resizeState.cols.map(function (col) {
+        if (!updated && col.width + diff > col.minWidth) {
+          updated = true;
+          return _objectSpread(_objectSpread({}, col), {}, {
+            width: col.width + diff
+          });
+        }
+
+        return col;
+      })
+    });
+  }
+
+  return resizeState;
+};
+
+exports.adjustColumnsWidths = adjustColumnsWidths;
+
+var evenAllColumnsWidths = function evenAllColumnsWidths(resizeState) {
+  var maxSize = getTotalWidth(resizeState);
+  var evenWidth = Math.floor(maxSize / resizeState.cols.length);
+  var cols = resizeState.cols.map(function (col) {
+    return _objectSpread(_objectSpread({}, col), {}, {
+      width: evenWidth
+    });
+  });
+  return adjustColumnsWidths(_objectSpread(_objectSpread({}, resizeState), {}, {
+    cols: cols
+  }), maxSize);
+};
+
+exports.evenAllColumnsWidths = evenAllColumnsWidths;
+
+var getSpace = function getSpace(columns, start, end) {
+  return columns.slice(start, end).map(function (col) {
+    return col.width;
+  }).reduce(function (sum, width) {
+    return sum + width;
+  }, 0);
+};
+
+var evenSelectedColumnsWidths = function evenSelectedColumnsWidths(resizeState, rect) {
+  var cols = resizeState.cols;
+  var selectedSpace = getSpace(cols, rect.left, rect.right);
+  var allSpace = getSpace(cols, 0, cols.length);
+  var allWidth = allSpace / cols.length;
+  var width = selectedSpace / (rect.right - rect.left); // Result equals even distribution of all columns -
+  // unset widths of all columns
+
+  if (allWidth === width) {
+    return _objectSpread(_objectSpread({}, resizeState), {}, {
+      widths: cols.map(function () {
+        return width;
+      }),
+      cols: resizeState.cols.map(function (col) {
+        return _objectSpread(_objectSpread({}, col), {}, {
+          width: 0
+        });
+      })
+    });
+  }
+
+  return _objectSpread(_objectSpread({}, resizeState), {}, {
+    widths: cols.map(function (col, i) {
+      return i >= rect.left && i < rect.right ? width : col.width;
+    }),
+    cols: cols.map(function (col, i) {
+      return _objectSpread(_objectSpread({}, col), {}, {
+        width: i >= rect.left && i < rect.right ? width : col.width
+      });
+    })
+  });
+};
+
+exports.evenSelectedColumnsWidths = evenSelectedColumnsWidths;
+
+var bulkColumnsResize = function bulkColumnsResize(resizeState, columnsIndexes, sourceColumnIndex) {
+  var currentTableWidth = getTotalWidth(resizeState);
+  var colIndex = columnsIndexes.indexOf(sourceColumnIndex) > -1 ? sourceColumnIndex : sourceColumnIndex + 1;
+  var sourceCol = resizeState.cols[colIndex];
+  var seenColumns = {};
+  var widthsDiffs = [];
+  var cols = resizeState.cols.map(function (col) {
+    if (columnsIndexes.indexOf(col.index) > -1) {
+      var diff = col.width - sourceCol.width;
+
+      if (diff !== 0) {
+        widthsDiffs.push(diff);
+      }
+
+      return _objectSpread(_objectSpread({}, col), {}, {
+        width: sourceCol.width
+      });
+    }
+
+    return col;
+  });
+
+  var newState = _objectSpread(_objectSpread({}, resizeState), {}, {
+    cols: cols.map(function (col) {
+      if (columnsIndexes.indexOf(col.index) > -1 || // take from prev columns only if dragging the first handle to the left
+      columnsIndexes.indexOf(sourceColumnIndex) > -1 && col.index < colIndex) {
+        return col;
+      }
+
+      while (widthsDiffs.length) {
+        var diff = widthsDiffs.shift() || 0;
+        var column = seenColumns[col.index] || col;
+        var maybeWidth = column.width + diff;
+
+        if (maybeWidth > column.minWidth) {
+          seenColumns[column.index] = _objectSpread(_objectSpread({}, column), {}, {
+            width: maybeWidth
+          });
+        } else {
+          widthsDiffs.push(maybeWidth - column.minWidth);
+          seenColumns[column.index] = _objectSpread(_objectSpread({}, column), {}, {
+            width: column.minWidth
+          });
+          break;
+        }
+      }
+
+      return seenColumns[col.index] || col;
+    })
+  }); // minimum possible table widths at the current layout
+
+
+  var minTableWidth = resizeState.maxSize; // new table widths after bulk resize
+
+  var newTotalWidth = getTotalWidth(newState); // when all columns are selected, what do we do when sum of columns widths is lower than min possible table widths?
+
+  if (columnsIndexes.length === resizeState.cols.length && newTotalWidth < minTableWidth) {
+    // table is not in overflow -> normal resize of a single column
+    if (currentTableWidth === minTableWidth) {
+      return resizeState;
+    } // table is in overflow: keep the dragged column at its widths and evenly distribute columns
+    // to recover from overflow state
+    else {
+      var columnWidth = Math.floor((minTableWidth - sourceCol.width) / (newState.cols.length - 1));
+      newState = _objectSpread(_objectSpread({}, resizeState), {}, {
+        cols: newState.cols.map(function (col) {
+          if (col.index === sourceCol.index) {
+            return col;
+          }
+
+          return _objectSpread(_objectSpread({}, col), {}, {
+            width: columnWidth
+          });
+        })
+      });
+    }
+  } // fix total table widths by adding missing pixels to columns widths here and there
+
+
+  return adjustColumnsWidths(newState, resizeState.maxSize);
+};
+
+exports.bulkColumnsResize = bulkColumnsResize;
+
+var areColumnsEven = function areColumnsEven(resizeState) {
+  var newResizeState = evenAllColumnsWidths(resizeState);
+  return newResizeState.cols.every(function (col, i) {
+    return col.width === resizeState.cols[i].width;
+  });
+}; // Get the layout
+
+
+exports.areColumnsEven = areColumnsEven;
+
+var normaliseTableLayout = function normaliseTableLayout(input) {
+  switch (input) {
+    case 'wide':
+      return input;
+
+    case 'full-width':
+      return input;
+
+    default:
+      return 'default';
+  }
+};
+
+exports.normaliseTableLayout = normaliseTableLayout;
+
+var getNewResizeStateFromSelectedColumns = function getNewResizeStateFromSelectedColumns(rect, state, domAtPos, getEditorContainerWidth) {
+  var _getSelectedTableInfo = (0, _utils2.getSelectedTableInfo)(state.selection),
+      totalRowCount = _getSelectedTableInfo.totalRowCount,
+      totalColumnCount = _getSelectedTableInfo.totalColumnCount,
+      table = _getSelectedTableInfo.table;
+
+  if (!table) {
+    return;
+  }
+
+  var maybeTable = domAtPos(table.start).node;
+  var tableRef = maybeTable.closest('table');
+
+  if (!tableRef) {
+    return;
+  }
+
+  var layout = normaliseTableLayout(tableRef === null || tableRef === void 0 ? void 0 : tableRef.dataset.layout);
+  var maxSize = (0, _misc.getTableMaxWidth)({
+    table: table.node,
+    tableStart: table.start,
+    state: state,
+    layout: layout,
+    getEditorContainerWidth: getEditorContainerWidth
+  });
+  var resizeState = getResizeState({
+    minWidth: _styles.tableCellMinWidth,
+    maxSize: maxSize,
+    table: table.node,
+    tableRef: tableRef,
+    start: table.start,
+    domAtPos: domAtPos
+  });
+  var newResizeState = evenSelectedColumnsWidths(resizeState, rect);
+  var widthsBefore = resizeState.widths;
+  var widthsAfter = newResizeState.widths;
+  var changed = resizeState.widths.some(function (widthBefore, index) {
+    return widthBefore !== widthsAfter[index];
+  });
+  return {
+    resizeState: newResizeState,
+    table: table,
+    changed: changed,
+    attributes: {
+      position: rect.left,
+      count: rect.right - rect.left,
+      totalRowCount: totalRowCount,
+      totalColumnCount: totalColumnCount,
+      widthsBefore: widthsBefore,
+      widthsAfter: widthsAfter
+    }
+  };
+};
+
+exports.getNewResizeStateFromSelectedColumns = getNewResizeStateFromSelectedColumns;

package/dist/cjs/plugins/table/pm-plugins/table-resizing/utils/scale-table.js

@@ -0,0 +1,132 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scale = void 0;
+exports.scaleTableTo = scaleTableTo;
+exports.scaleWithParent = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _styles = require("@atlaskit/editor-common/styles");
+
+var _editorSharedStyles = require("@atlaskit/editor-shared-styles");
+
+var _utils = require("../../../utils");
+
+var _misc = require("../utils/misc");
+
+var _resizeLogic = require("../utils/resize-logic");
+
+var _resizeState = require("../utils/resize-state");
+
+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; }
+
+// Base function to trigger the actual scale on a table node.
+// Will only resize/scale if a table has been previously resized.
+var scale = function scale(tableRef, options, domAtPos) {
+  /**
+   * isBreakoutEnabled === true -> default center aligned
+   * isBreakoutEnabled === false -> full width mode
+   */
+  var node = options.node,
+      containerWidth = options.containerWidth,
+      previousContainerWidth = options.previousContainerWidth,
+      prevNode = options.prevNode,
+      start = options.start,
+      isBreakoutEnabled = options.isBreakoutEnabled,
+      layoutChanged = options.layoutChanged;
+  var maxSize = (0, _misc.getLayoutSize)(node.attrs.layout, containerWidth, {
+    isBreakoutEnabled: isBreakoutEnabled
+  });
+  var prevTableWidth = (0, _utils.getTableWidth)(prevNode);
+  var previousMaxSize = (0, _misc.getLayoutSize)(prevNode.attrs.layout, previousContainerWidth, {
+    isBreakoutEnabled: isBreakoutEnabled
+  });
+  var newWidth = maxSize; // adjust table width if layout is updated
+
+  var hasOverflow = prevTableWidth > previousMaxSize;
+
+  if (layoutChanged && hasOverflow) {
+    // No keep overflow if the old content can be in the new size
+    var canFitInNewSize = prevTableWidth < maxSize;
+
+    if (canFitInNewSize) {
+      newWidth = maxSize;
+    } else {
+      // Keep the same scale.
+      var overflowScale = prevTableWidth / previousMaxSize;
+      newWidth = Math.floor(newWidth * overflowScale);
+    }
+  }
+
+  if (node.attrs.isNumberColumnEnabled) {
+    newWidth -= _editorSharedStyles.akEditorTableNumberColumnWidth;
+  }
+
+  var resizeState = (0, _resizeState.getResizeState)({
+    minWidth: _styles.tableCellMinWidth,
+    maxSize: maxSize,
+    table: node,
+    tableRef: tableRef,
+    start: start,
+    domAtPos: domAtPos
+  });
+  return scaleTableTo(resizeState, newWidth);
+};
+
+exports.scale = scale;
+
+var scaleWithParent = function scaleWithParent(tableRef, parentWidth, table, start, domAtPos) {
+  var resizeState = (0, _resizeState.getResizeState)({
+    minWidth: _styles.tableCellMinWidth,
+    maxSize: parentWidth,
+    table: table,
+    tableRef: tableRef,
+    start: start,
+    domAtPos: domAtPos
+  });
+
+  if (table.attrs.isNumberColumnEnabled) {
+    parentWidth -= _editorSharedStyles.akEditorTableNumberColumnWidth;
+  }
+
+  return scaleTableTo(resizeState, Math.floor(parentWidth));
+}; // Scales the table to a given size and updates its colgroup DOM node
+
+
+exports.scaleWithParent = scaleWithParent;
+
+function scaleTableTo(state, maxSize) {
+  var scaleFactor = maxSize / (0, _resizeState.getTotalWidth)(state);
+
+  var newState = _objectSpread(_objectSpread({}, state), {}, {
+    maxSize: maxSize,
+    cols: state.cols.map(function (col) {
+      var minWidth = col.minWidth,
+          width = col.width;
+      var newColWidth = Math.floor(width * scaleFactor);
+
+      if (newColWidth < minWidth) {
+        newColWidth = minWidth;
+      }
+
+      return _objectSpread(_objectSpread({}, col), {}, {
+        width: newColWidth
+      });
+    })
+  });
+
+  var newTotalWidth = (0, _resizeState.getTotalWidth)(newState);
+
+  if (newTotalWidth > maxSize) {
+    newState = (0, _resizeLogic.reduceSpace)(newState, newTotalWidth - maxSize);
+  }
+
+  return (0, _resizeState.adjustColumnsWidths)(newState, maxSize);
+}

package/dist/cjs/plugins/table/pm-plugins/table-resizing/utils/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/cjs/plugins/table/pm-plugins/table-resizing/utils/unit-to-number.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unitToNumber = void 0;
+
+var unitToNumber = function unitToNumber(unit) {
+  return unit ? parseInt(unit, 10) : 0;
+};
+
+exports.unitToNumber = unitToNumber;

package/dist/cjs/plugins/table/pm-plugins/table-selection-keymap.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.tableSelectionKeymapPlugin = tableSelectionKeymapPlugin;
+
+var _prosemirrorKeymap = require("prosemirror-keymap");
+
+var _keymaps = require("@atlaskit/editor-common/keymaps");
+
+var _selection = require("../commands/selection");
+
+function tableSelectionKeymapPlugin(editorSelectionAPI) {
+  var list = {};
+  (0, _keymaps.bindKeymapWithCommand)(_keymaps.moveRight.common, (0, _selection.arrowRightFromTable)(editorSelectionAPI)(), list);
+  (0, _keymaps.bindKeymapWithCommand)(_keymaps.moveLeft.common, (0, _selection.arrowLeftFromTable)(editorSelectionAPI)(), list);
+  return (0, _prosemirrorKeymap.keymap)(list);
+}
+
+var _default = tableSelectionKeymapPlugin;
+exports.default = _default;

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

@@ -0,0 +1,107 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _defaultTableSelection = require("./pm-plugins/default-table-selection");
+
+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 _default = function _default(pluginState, action) {
+  switch (action.type) {
+    case 'TOGGLE_HEADER_COLUMN':
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        isHeaderColumnEnabled: !pluginState.isHeaderColumnEnabled
+      });
+
+    case 'TOGGLE_HEADER_ROW':
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        isHeaderRowEnabled: !pluginState.isHeaderRowEnabled
+      });
+
+    case 'CLEAR_HOVER_SELECTION':
+      return _objectSpread(_objectSpread(_objectSpread({}, pluginState), action.data), _defaultTableSelection.defaultTableSelection);
+
+    case 'SELECT_COLUMN':
+      return _objectSpread(_objectSpread(_objectSpread({}, pluginState), action.data), {}, {
+        isContextualMenuOpen: false
+      });
+
+    case 'SET_TARGET_CELL_POSITION':
+      return _objectSpread(_objectSpread(_objectSpread({}, pluginState), action.data), {}, {
+        isContextualMenuOpen: false
+      });
+
+    case 'SET_TABLE_LAYOUT':
+      return _objectSpread(_objectSpread({}, pluginState), action.data);
+
+    case 'TOGGLE_CONTEXTUAL_MENU':
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        isContextualMenuOpen: !pluginState.isContextualMenuOpen
+      });
+
+    case 'SHOW_INSERT_ROW_BUTTON':
+      if (action.data.insertRowButtonIndex === pluginState.insertRowButtonIndex) {
+        return pluginState;
+      }
+
+      return _objectSpread(_objectSpread(_objectSpread({}, pluginState), action.data), {}, {
+        insertColumnButtonIndex: undefined // We need to assure that column is not shown
+
+      });
+
+    case 'SHOW_INSERT_COLUMN_BUTTON':
+      if (action.data.insertColumnButtonIndex === pluginState.insertColumnButtonIndex) {
+        return pluginState;
+      }
+
+      return _objectSpread(_objectSpread(_objectSpread({}, pluginState), action.data), {}, {
+        insertRowButtonIndex: undefined // We need to assure that row is not shown
+
+      });
+
+    case 'HIDE_INSERT_COLUMN_OR_ROW_BUTTON':
+      if (pluginState.insertRowButtonIndex !== undefined || pluginState.insertColumnButtonIndex !== undefined) {
+        return _objectSpread(_objectSpread({}, pluginState), {}, {
+          insertRowButtonIndex: undefined,
+          insertColumnButtonIndex: undefined
+        });
+      }
+
+      return pluginState;
+
+    case 'HIDE_RESIZE_HANDLE_LINE':
+      return _objectSpread(_objectSpread(_objectSpread({}, pluginState), action.data), {}, {
+        resizeHandleColumnIndex: undefined
+      });
+
+    case 'ADD_RESIZE_HANDLE_DECORATIONS':
+      if (action.data.resizeHandleColumnIndex === pluginState.resizeHandleColumnIndex) {
+        return pluginState;
+      }
+
+      return _objectSpread(_objectSpread({}, pluginState), action.data);
+
+    case 'SET_TABLE_REF':
+    case 'HOVER_ROWS':
+    case 'HOVER_COLUMNS':
+    case 'HOVER_TABLE':
+    case 'HOVER_CELLS':
+    case 'SHOW_RESIZE_HANDLE_LINE':
+    case 'SET_EDITOR_FOCUS':
+      return _objectSpread(_objectSpread({}, pluginState), action.data);
+
+    default:
+      return pluginState;
+  }
+};
+
+exports.default = _default;

package/dist/cjs/plugins/table/todo-stubs.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sendLogs = void 0;
+
+var sendLogs = function sendLogs(_a) {};
+
+exports.sendLogs = sendLogs;