@modusoperandi/licit 0.14.18 → 1.0.1

package/TableResizePlugin.js

@@ -0,0 +1,542 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+// Copyright (C) 2015-2016 by Marijn Haverbeke <marijnh@gmail.com> and others
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+// License about this file:
+// This file is originally forked from
+// https://github.com/ProseMirror/prosemirror-tables/blob/0e74c6a1761651ccf3701eb8529fa9187ad5c91d/src/columnresizing.js
+// and most of the original codes had been modified to support the bevaviors
+// that czi-prosemirror needs.
+// The plugin provides the following behaviors:
+// - Let user resize a column without changing the total width of the table.
+// - Let user set the left margin of the table.
+// - Let user set the right margin of the table.
+import TableNodeView from './ui/TableNodeView.js';
+import { Node } from 'prosemirror-model';
+import { EditorState, Plugin, PluginKey } from 'prosemirror-state';
+import { Transform } from 'prosemirror-transform';
+import { Decoration, DecorationSet, EditorView } from 'prosemirror-view';
+import { findParentNodeOfTypeClosestToPos } from 'prosemirror-utils';
+import nullthrows from 'nullthrows';
+import { cellAround, pointsAtCell, setCellAttr, tableNodeTypes, TableMap, TableView } from 'prosemirror-tables';
+var PLUGIN_KEY = new PluginKey('tableColumnResizing');
+
+// [FS] IRAD-949 2020-05-27
+// Fix:Cell Resize Handler causes edit diificult to firsrst/last two chars in the cell.
+// Rezie cursor position issue fixed.
+
+var CELL_MIN_WIDTH = 30;
+var HANDLE_WIDTH = 5;
+var HANDLE_RIGHT_WIDTH = 20;
+var cancelDrag = null;
+var isEnabled = true;
+
+// The immutable plugin state that stores the information for resizing.
+var ResizeState = /*#__PURE__*/function () {
+  function ResizeState(cellPos, forMarginLeft, draggingInfo) {
+    _classCallCheck(this, ResizeState);
+    _defineProperty(this, "cellPos", void 0);
+    _defineProperty(this, "forMarginLeft", void 0);
+    _defineProperty(this, "draggingInfo", void 0);
+    this.cellPos = cellPos;
+    this.draggingInfo = draggingInfo;
+    this.forMarginLeft = forMarginLeft;
+  }
+  _createClass(ResizeState, [{
+    key: "apply",
+    value: function apply(tr) {
+      var state = this;
+      var action = tr.getMeta(PLUGIN_KEY);
+      if (action && typeof action.setCellPos === 'number') {
+        return new ResizeState(action.setCellPos, action.setForMarginLeft, null);
+      }
+      if (action && action.setDraggingInfo !== undefined) {
+        return new ResizeState(state.cellPos, state.forMarginLeft, action.setDraggingInfo);
+      }
+      if (state.cellPos && state.cellPos > -1 && tr.docChanged) {
+        var cellPos = tr.mapping.map(state.cellPos, -1);
+        if (!pointsAtCell(tr.doc.resolve(cellPos))) {
+          cellPos = null;
+        }
+        state = new ResizeState(cellPos, cellPos ? state.forMarginLeft : false, state.draggingInfo);
+      }
+      return state;
+    }
+  }]);
+  return ResizeState;
+}(); // Function that handles the mousemove event inside table cell.
+function handleMouseMove(view, event) {
+  var resizeState = PLUGIN_KEY.getState(view.state);
+  if (resizeState.draggingInfo) {
+    return;
+  }
+  var target = domCellAround(event.target);
+  var forMarginLeft = false;
+  var cell = -1;
+  if (target instanceof HTMLTableCellElement) {
+    var _target$getBoundingCl = target.getBoundingClientRect(),
+      left = _target$getBoundingCl.left,
+      right = _target$getBoundingCl.right;
+    var offsetLeft = event.clientX - left;
+    // [FS] IRAD-949 2020-05-27
+    // Fix:Cell Resize Handler causes edit diificult to firsrst/last two chars in the cell.
+    // Rezie cursor position issue fixed.
+    if (offsetLeft <= HANDLE_WIDTH) {
+      if (target.cellIndex === 0) {
+        forMarginLeft = true;
+        cell = edgeCell(view, event, 'right');
+      } else {
+        cell = edgeCell(view, event, 'left');
+      }
+    } else if (right - event.clientX <= HANDLE_WIDTH) {
+      cell = edgeCell(view, event, 'right');
+    }
+  }
+  if (cell === resizeState.cellPos && forMarginLeft === resizeState.forMarginLeft) {
+    return;
+  }
+  if (cell !== -1) {
+    var $cell = view.state.doc.resolve(cell);
+    if (!$cell) {
+      return;
+    }
+  }
+  updateResizeHandle(view, cell, forMarginLeft);
+}
+
+// Function that handles the mouseleave event from the table cell.
+function handleMouseLeave(view) {
+  var resizeState = PLUGIN_KEY.getState(view.state);
+  var cellPos = resizeState.cellPos,
+    draggingInfo = resizeState.draggingInfo;
+  if (cellPos > -1 && !draggingInfo) {
+    updateResizeHandle(view, -1, false);
+  }
+}
+
+// Function that handles the mousedown event from the table cell.
+function handleMouseDown(view, event) {
+  var _this = this;
+  // It's possible that the resize action that happened earlier was inturrupted
+  // while its dependent mouse events were stopped or prevented by others.
+  // We need to stop the previous resize action if it did not finish.
+  cancelDrag && cancelDrag(event);
+  var resizeState = PLUGIN_KEY.getState(view.state);
+  if (resizeState.cellPos === -1 || resizeState.draggingInfo) {
+    return false;
+  }
+  var dragStarted = false;
+  var dragMoveHandler = null;
+  var finish = function finish(event) {
+    window.removeEventListener('mouseup', finish, true);
+    window.removeEventListener('mousemove', _this.move, true);
+    dragStarted && handleDragEnd(view, event);
+    cancelDrag = null;
+  };
+  var move = function move(event) {
+    if (event.which) {
+      if (!dragStarted) {
+        handleDragStart(view, event);
+        dragStarted = true;
+      }
+      // Move events should be batched to avoid over-handling the mouse
+      // event.
+      dragMoveHandler = dragMoveHandler || batchMouseHandler(handleDragMove);
+      dragMoveHandler(view, event);
+    } else {
+      finish(event);
+    }
+  };
+  cancelDrag = finish;
+  window.addEventListener('mouseup', finish, true);
+  window.addEventListener('mousemove', move, true);
+  event.preventDefault();
+  return true;
+}
+function handleDragStart(view, event) {
+  var resizeState = PLUGIN_KEY.getState(view.state);
+  if (resizeState.cellPos === -1 || resizeState.draggingInfo) {
+    return;
+  }
+  view.dispatch(view.state.tr.setMeta(PLUGIN_KEY, {
+    setDraggingInfo: calculateDraggingInfo(view, event, resizeState)
+  }));
+}
+
+// Function that handles the mouse event while resizing the table cell.
+// This will temporarily updates the table's style until the resize ends.
+function handleDragMove(view, event) {
+  var resizeState = PLUGIN_KEY.getState(view.state);
+  var draggingInfo = resizeState.draggingInfo,
+    forMarginLeft = resizeState.forMarginLeft;
+  if (!draggingInfo) {
+    return;
+  }
+  var startX = draggingInfo.startX,
+    columnWidths = draggingInfo.columnWidths,
+    taregtColumnIndex = draggingInfo.taregtColumnIndex,
+    columnElements = draggingInfo.columnElements,
+    tableElement = draggingInfo.tableElement,
+    tableMarginLeft = draggingInfo.tableMarginLeft,
+    tableMarginRight = draggingInfo.tableMarginRight;
+  var totalWidth = 0;
+  var ml = tableMarginLeft;
+  var dx = event.clientX - startX;
+  var lastIndex = columnWidths.length - 1;
+  var widths = columnWidths.map(function (cw, index) {
+    var ww;
+    if (forMarginLeft) {
+      if (index === 0) {
+        // Resize the first column.
+        ww = Math.min(Math.max(CELL_MIN_WIDTH, cw - dx), cw + tableMarginLeft);
+        // Resize table's left margin.
+        ml = Math.max(0, tableMarginLeft + cw - ww);
+      } else {
+        // The rest columns remain the same,
+        ww = cw;
+      }
+    } else if (index === taregtColumnIndex && index === lastIndex) {
+      // Resize the last column.
+      ww = Math.min(cw + tableMarginRight, Math.max(CELL_MIN_WIDTH, cw + dx));
+    } else if (index === taregtColumnIndex) {
+      // Resize the column.
+      ww = Math.min(Math.max(CELL_MIN_WIDTH, cw + dx), cw + (columnWidths[index + 1] || 0) - CELL_MIN_WIDTH);
+    } else if (index === taregtColumnIndex + 1) {
+      // Resize the column's previous column.
+      ww = Math.min(Math.max(CELL_MIN_WIDTH, cw - dx), cw + (columnWidths[index - 1] || 0) - CELL_MIN_WIDTH);
+    } else {
+      // This column does not resize.
+      ww = cw;
+    }
+    totalWidth += ww;
+    return ww;
+  });
+  var tableElementStyle = tableElement.style;
+  tableElementStyle.marginLeft = "".concat(ml, "px");
+  // [FS] IRAD-993 2020-06-26
+  // Fix:Table exceeds the canvas
+  tableElementStyle.width = Math.round(totalWidth - ml) + 'px';
+  tableElementStyle.minWidth = '';
+  columnElements.forEach(function (colEl, index) {
+    colEl.style.width = Math.round(widths[index]) + 'px';
+  });
+}
+
+// Function that handles the mouse event while stop resizing the table cell.
+function handleDragEnd(view, event) {
+  var resizeState = PLUGIN_KEY.getState(view.state);
+  var cellPos = resizeState.cellPos,
+    draggingInfo = resizeState.draggingInfo;
+  if (!draggingInfo) {
+    return;
+  }
+  var columnElements = draggingInfo.columnElements,
+    tableElement = draggingInfo.tableElement;
+  var widths = columnElements.map(function (colEl) {
+    return parseFloat(colEl.style.width);
+  });
+  var $cell = view.state.doc.resolve(cellPos);
+  var start = $cell.start(-1);
+  var table = $cell.node(-1);
+  var map = TableMap.get(table);
+  var tr = view.state.tr;
+  for (var row = 0; row < map.height; row++) {
+    for (var col = 0; col < widths.length; col++) {
+      var mapIndex = row * map.width + col;
+      if (row && map.map[mapIndex] == map.map[mapIndex - map.width]) {
+        // Rowspanning cell that has already been handled
+        continue;
+      }
+      var pos = map.map[mapIndex];
+      var _table$nodeAt = table.nodeAt(pos),
+        attrs = _table$nodeAt.attrs;
+      var colspan = attrs.colspan || 1;
+      var colwidth = widths.slice(col, col + colspan);
+      if (colspan > 1) {
+        // The current cell spans across multiple columns, this forwards to
+        // the next cell for the next iteration.
+        col += colspan - 1;
+      }
+      if (attrs.colwidth && compareNumbersList(attrs.colwidth, colwidth)) {
+        continue;
+      }
+      tr = tr.setNodeMarkup(start + pos, null, setCellAttr('colwidth', colwidth));
+    }
+  }
+  var marginLeft = parseFloat(tableElement.style.marginLeft) || null;
+  if (table.attrs.marginLeft !== marginLeft) {
+    var nodeType = table.type;
+    var _attrs = _objectSpread(_objectSpread({}, table.attrs), {}, {
+      marginLeft: marginLeft
+    });
+    var tableLookup = findParentNodeOfTypeClosestToPos($cell, view.state.schema.nodes[nodeType.name]);
+    var tablePos = nullthrows(tableLookup && tableLookup.pos);
+    tr = tr.setNodeMarkup(tablePos, nodeType, _attrs);
+  }
+  if (tr.docChanged) {
+    // Let editor know the change.
+    view.dispatch(tr);
+  }
+  // Hides the resize handle bars.
+  view.dispatch(view.state.tr.setMeta(PLUGIN_KEY, {
+    setDraggingInfo: null
+  }));
+}
+
+// Helper that prepares the information needed before the resizing starts.
+function calculateDraggingInfo(view, event, resizeState) {
+  var cellPos = resizeState.cellPos,
+    forMarginLeft = resizeState.forMarginLeft;
+  var dom = view.domAtPos(cellPos);
+  var tableEl = dom.node.closest('table');
+  var tableWrapper = tableEl.closest('.tableWrapper');
+  var colGroupEl = tableEl.querySelector('colgroup');
+  var colEls = colGroupEl ? Array.from(colGroupEl.querySelectorAll('col')) : [];
+  var tableWrapperRect = tableWrapper.getBoundingClientRect();
+  var tableRect = tableEl.getBoundingClientRect();
+  var defaultColumnWidth = tableWrapperRect.width / colEls.length;
+  var startX = event.clientX;
+  var offsetLeft = startX - tableRect.left;
+  var tableWidth = 0;
+  var taregtColumnIndex = -1;
+  var tableMarginLeftStyle = tableEl.style.marginLeft;
+  var tableMarginLeft = tableMarginLeftStyle && /\d+px/.test(tableMarginLeftStyle) ? parseFloat(tableMarginLeftStyle) : 0;
+  var tableMarginRight = tableWrapperRect.right - tableRect.right;
+
+  // Calculate the inital width of each column.
+  // Calculate the inital width of the table.
+  // Find out the target column to resize.
+  var columnWidths = Array.from(colEls).map(function (colEl, ii) {
+    var cssWidth = colEl.style.width;
+    var colWidth = Math.max(CELL_MIN_WIDTH, cssWidth && parseFloat(cssWidth) || defaultColumnWidth);
+    if (tableWidth + colWidth > tableWrapperRect.width) {
+      // column is too wide, make it fit.
+      // colWidth -= tableWrapperRect.width - (tableWidth + colWidth);
+      // [FS] IRAD-993 2020-06-24
+      // Fix:Table exceeds the canvas
+      var tosub = Math.abs(tableWrapperRect.width - (tableWidth + colWidth));
+      colWidth = colWidth - tosub;
+    }
+
+    // The edges of the column's right border.
+    // [FS] IRAD-949 2020-05-27
+    // Fix:Cell Resize Handler causes edit diificult to firsrst/last two chars in the cell.
+    var edgeLeft = tableWidth + colWidth - HANDLE_RIGHT_WIDTH / 2;
+    var edgeRight = tableWidth + colWidth + HANDLE_RIGHT_WIDTH / 2;
+    if (offsetLeft >= edgeLeft && offsetLeft <= edgeRight) {
+      // [FS] IRAD-993 2020-06-24
+      // Fix:Table exceeds the canvas
+      if (taregtColumnIndex === -1) {
+        // This is the column to resize.
+        taregtColumnIndex = ii;
+      }
+    }
+    tableWidth += colWidth;
+    return colWidth;
+  });
+  if (forMarginLeft) {
+    // Both the first column and the table's left margin should resize.
+    taregtColumnIndex = 0;
+  }
+  if (taregtColumnIndex < 0) {
+    // Nothing to resize. This happens when the mouse isn't nearby any position
+    // that is alllowed to resize a column.
+    return null;
+  }
+  return {
+    columnElements: colEls,
+    taregtColumnIndex: taregtColumnIndex,
+    columnWidths: columnWidths,
+    startX: startX,
+    tableElement: tableEl,
+    tableMarginLeft: tableMarginLeft,
+    tableMarginRight: tableMarginRight,
+    tableWidth: tableWidth,
+    tableWrapperWidth: tableWrapperRect.width
+  };
+}
+
+// Helper that finds the closest cell element from a given event target.
+function domCellAround(target) {
+  while (target && target.nodeName !== 'TD' && target.nodeName !== 'TH') {
+    target = target.classList.contains('ProseMirror') ? null : target.parentElement;
+  }
+  return target;
+}
+
+// Helper that resolves the prose-mirror node postion of a cell from a given
+// event target.
+function edgeCell(view, event, side) {
+  var _view$posAtCoords = view.posAtCoords({
+      left: event.clientX,
+      top: event.clientY
+    }),
+    pos = _view$posAtCoords.pos;
+  var $cell = cellAround(view.state.doc.resolve(pos));
+  if (!$cell) {
+    return -1;
+  }
+  if (side == 'right') {
+    return $cell.pos;
+  }
+  var map = TableMap.get($cell.node(-1));
+  var start = $cell.start(-1);
+  var index = map.map.indexOf($cell.pos - start);
+  return index % map.width == 0 ? -1 : start + map.map[index - 1];
+}
+
+// Update the resize handler (UI) state.
+function updateResizeHandle(view, cellPos, forMarginLeft) {
+  view.dispatch(view.state.tr.setMeta(PLUGIN_KEY, {
+    setCellPos: cellPos,
+    setForMarginLeft: forMarginLeft
+  }));
+}
+
+// Get the decorations that renders the resize handle bars.
+function handleDecorations(state, resizeState) {
+  if (!resizeState.cellPos) {
+    return DecorationSet.create(state.doc, []);
+  }
+  var decorations = [];
+  var $cell = state.doc.resolve(resizeState.cellPos);
+  var table = $cell.node(-1);
+  var map = TableMap.get(table);
+  var start = $cell.start(-1);
+  var col = map.colCount($cell.pos - start) + $cell.nodeAfter.attrs.colspan;
+  for (var row = 0; row < map.height; row++) {
+    var index = col + row * map.width - 1;
+    // For positions that are have either a different cell or the end
+    // of the table to their right, and either the top of the table or
+    // a different cell above them, add a decoration
+    if ((col === map.width || map.map[index] !== map.map[index + 1]) && (row === 0 || map.map[index - 1] !== map.map[index - 1 - map.width])) {
+      var cellPos = map.map[index];
+      var pos = start + cellPos + table.nodeAt(cellPos).nodeSize - 1;
+      var dom = document.createElement('div');
+      var className = 'column-resize-handle';
+      if (resizeState.forMarginLeft) {
+        className += ' for-margin-left';
+      }
+      dom.className = className;
+      decorations.push(Decoration.widget(pos, dom));
+    }
+  }
+  return DecorationSet.create(state.doc, decorations);
+}
+
+// Creates a custom table view that renders the margin-left style.
+function createTableView(node, view) {
+  // [FS] IRAD-1008 2020-07-16
+  // Does not allow Table cell Resize in disable mode
+  isEnabled = view.editable;
+  return new TableNodeView(node, CELL_MIN_WIDTH, view);
+}
+function batchMouseHandler(handler) {
+  var target = null;
+  var clientX = 0;
+  var clientY = 0;
+  var view = null;
+  var onMouseEvent = function onMouseEvent() {
+    if (view && target) {
+      var pointerEvent = {
+        target: target,
+        clientX: clientX,
+        clientY: clientY
+      };
+      handler(view, pointerEvent);
+    }
+  };
+  return function (ev, me) {
+    target = me.target;
+    clientX = me.clientX;
+    clientY = me.clientY;
+    view = ev;
+    requestAnimationFrame(onMouseEvent);
+  };
+}
+function compareNumbersList(one, two) {
+  if (one.length !== two.length) {
+    return false;
+  }
+  return !one.some(function (value, index) {
+    return two[index] !== value;
+  });
+}
+
+// Plugin that supports table columns resizing.
+var TableResizePlugin = /*#__PURE__*/function (_Plugin) {
+  _inherits(TableResizePlugin, _Plugin);
+  // [FS] IRAD-1005 2020-07-07
+  // Upgrade outdated packages.
+  //spec: Object;
+
+  function TableResizePlugin() {
+    _classCallCheck(this, TableResizePlugin);
+    return _callSuper(this, TableResizePlugin, [{
+      key: PLUGIN_KEY,
+      state: {
+        init: function init(_, state) {
+          if (!this.spec.props.nodeViews['table']) {
+            this.spec.props.nodeViews[tableNodeTypes(state.schema).table.name] = createTableView;
+          }
+          return new ResizeState(-1, null);
+        },
+        apply: function apply(tr, prev) {
+          return prev.apply(tr);
+        }
+      },
+      props: {
+        attributes: function attributes(state) {
+          var resizeState = PLUGIN_KEY.getState(state);
+          return resizeState.cellPos > -1 ? {
+            "class": 'resize-cursor'
+          } : null;
+        },
+        handleDOMEvents: {
+          // Move events should be batched to avoid over-handling the mouse
+          // event.
+          mousemove: batchMouseHandler(handleMouseMove),
+          mouseleave: handleMouseLeave,
+          mousedown: handleMouseDown
+        },
+        decorations: function decorations(state) {
+          var resizeState = PLUGIN_KEY.getState(state);
+          // [FS] IRAD-1008 2020-07-16
+          // Does not allow Table cell Resize in disable mode
+          return resizeState.cellPos > -1 && isEnabled ? handleDecorations(state, resizeState) : undefined;
+        },
+        nodeViews: {}
+      }
+    }]);
+  }
+  return _createClass(TableResizePlugin);
+}(Plugin);
+export { TableResizePlugin as default };