@atlaskit/editor-plugin-table 0.0.0 → 0.0.1

package/dist/esm/plugins/table/pm-plugins/sticky-headers/nodeviews/tableRow.js

@@ -0,0 +1,588 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { findOverflowScrollParent } from '@atlaskit/editor-common/ui';
+import { mapChildren } from '@atlaskit/editor-common/utils';
+import { TableCssClassName as ClassName, TableCssClassName } from '../../../types';
+import { stickyHeaderBorderBottomWidth, stickyRowOffsetTop, tableControlsSpacing, tableScrollbarOffset } from '../../../ui/consts';
+import { pluginKey as tablePluginKey } from '../../plugin-key';
+import { syncStickyRowToTable, updateStickyMargins as updateTableMargin } from '../../table-resizing/utils/dom';
+import { updateStickyState } from '../commands';
+import { getTop, getTree } from './dom';
+import debounce from 'lodash/debounce';
+import throttle from 'lodash/throttle'; // limit scroll event calls
+
+var HEADER_ROW_SCROLL_THROTTLE_TIMEOUT = 200; // timeout for resetting the scroll class - if it’s too long then users won’t be able to click on the header cells,
+// if too short it would trigger too many dom udpates.
+
+var HEADER_ROW_SCROLL_RESET_DEBOUNCE_TIMEOUT = 400;
+export var supportedHeaderRow = function supportedHeaderRow(node) {
+  var allHeaders = mapChildren(node, function (child) {
+    return child.type.name === 'tableHeader';
+  }).every(Boolean);
+  var someMerged = mapChildren(node, function (child) {
+    return child.attrs.rowspan || 0;
+  }).some(function (rowspan) {
+    return rowspan > 1;
+  });
+  return allHeaders && !someMerged;
+};
+export var TableRowNodeView = /*#__PURE__*/function () {
+  function TableRowNodeView(node, view, getPos, eventDispatcher, getEditorFeatureFlags) {
+    var _this = this;
+
+    _classCallCheck(this, TableRowNodeView);
+
+    _defineProperty(this, "colControlsOffset", 0);
+
+    _defineProperty(this, "focused", false);
+
+    _defineProperty(this, "topPosEditorElement", 0);
+
+    _defineProperty(this, "stickyHeadersOptimization", false);
+
+    _defineProperty(this, "sentinels", {});
+
+    _defineProperty(this, "listening", false);
+
+    _defineProperty(this, "headerRowMouseScrollEnd", debounce(function () {
+      _this.dom.classList.remove('no-pointer-events');
+    }, HEADER_ROW_SCROLL_RESET_DEBOUNCE_TIMEOUT));
+
+    _defineProperty(this, "headerRowMouseScroll", throttle(function () {
+      if (_this.isSticky) {
+        _this.dom.classList.add('no-pointer-events');
+
+        _this.headerRowMouseScrollEnd();
+      }
+    }, HEADER_ROW_SCROLL_THROTTLE_TIMEOUT));
+
+    _defineProperty(this, "onScroll", function () {
+      if (!_this.tree) {
+        return;
+      }
+
+      _this.latestDomTop = getTop(_this.tree.wrapper); // kick off rAF loop again if it hasn't already happened
+
+      if (!_this.nextFrame) {
+        _this.loop();
+      }
+    });
+
+    _defineProperty(this, "loop", function () {
+      _this.nextFrame = window.requestAnimationFrame(function () {
+        if (_this.previousDomTop === _this.latestDomTop && _this.previousPadding === _this.padding) {
+          _this.nextFrame = undefined;
+          return;
+        } // can't store these since React might re-render at any time
+
+
+        var tree = _this.tree;
+
+        if (!tree) {
+          _this.nextFrame = undefined;
+          return;
+        }
+
+        _this.paint(tree); // run again on next frame
+
+
+        _this.previousPadding = _this.padding;
+        _this.previousDomTop = _this.latestDomTop;
+
+        _this.loop();
+      });
+    });
+
+    _defineProperty(this, "paint", function (tree) {
+      var table = tree.table,
+          wrapper = tree.wrapper; // If the previous refresh is less than 10ms then don't do anything.
+      // The jumpiness happen under that time and this is to avoid it.
+
+      var timelapse = Math.abs(performance.now() - _this.lastTimePainted);
+
+      if (timelapse < 10) {
+        return;
+      }
+
+      if (_this.shouldHeaderStick(tree)) {
+        _this.makeHeaderRowSticky(tree);
+      } else {
+        _this.makeRowHeaderNotSticky(table);
+      } // ensure scroll positions are locked
+
+
+      _this.dom.scrollLeft = wrapper.scrollLeft;
+      _this.lastTimePainted = performance.now();
+    });
+
+    _defineProperty(this, "onTablePluginState", function (state) {
+      var tableRef = state.tableRef;
+      var focusChanged = false;
+      var tree = _this.tree;
+
+      if (!tree) {
+        return;
+      } // make it non-sticky initially to avoid making it look separated
+
+
+      if (!_this.isTableInit) {
+        if (_this.tree) {
+          _this.makeRowHeaderNotSticky(_this.tree.table);
+
+          _this.isTableInit = true;
+        }
+      } // when header rows are toggled off - mark sentinels as unobserved
+
+
+      if (!state.isHeaderRowEnabled) {
+        [_this.sentinels.top, _this.sentinels.bottom].forEach(function (el) {
+          if (el) {
+            delete el.dataset.isObserved;
+          }
+        });
+      }
+
+      var isCurrentTableSelected = tableRef === tree.table;
+
+      if (isCurrentTableSelected !== _this.focused) {
+        focusChanged = true;
+      }
+
+      _this.focused = isCurrentTableSelected;
+      var wrapper = tree.wrapper;
+      var tableContainer = wrapper.parentElement;
+      var tableContentWrapper = tableContainer.parentElement;
+      var layoutContainer = tableContentWrapper && tableContentWrapper.parentElement;
+
+      if (isCurrentTableSelected) {
+        _this.colControlsOffset = tableControlsSpacing;
+
+        if (layoutContainer && layoutContainer.getAttribute('data-layout-content')) {
+          // move table a little out of the way
+          // to provide spacing for table controls
+          tableContentWrapper.style.paddingLeft = '11px';
+        }
+      } else {
+        _this.colControlsOffset = 0;
+
+        if (layoutContainer && layoutContainer.getAttribute('data-layout-content')) {
+          tableContentWrapper.style.removeProperty('padding-left');
+        }
+      } // run after table style changes have been committed
+
+
+      setTimeout(function () {
+        // if focus changed while header is sticky - still repaint the positions will shift
+        if (!_this.stickyHeadersOptimization || focusChanged && _this.isSticky) {
+          _this.paint(tree);
+        }
+
+        syncStickyRowToTable(tree.table);
+      }, 0);
+    });
+
+    _defineProperty(this, "onWidthPluginState", function () {
+      // table width might have changed, sync that back to sticky row
+      var tree = _this.tree;
+
+      if (!tree) {
+        return;
+      }
+
+      syncStickyRowToTable(tree.table);
+    });
+
+    _defineProperty(this, "shouldHeaderStick", function (tree) {
+      var wrapper = tree.wrapper;
+      var tableWrapperRect = wrapper.getBoundingClientRect();
+
+      var editorAreaRect = _this.editorScrollableElement.getBoundingClientRect();
+
+      var stickyHeaderRect = _this.contentDOM.getBoundingClientRect();
+
+      var firstHeaderRow = !_this.dom.previousElementSibling;
+      var subsequentRows = !!_this.dom.nextElementSibling;
+      var isHeaderValid = firstHeaderRow && subsequentRows; // if the table wrapper is less than the editor top pos then make it sticky
+      // Make header sticky if table wrapper top is outside viewport
+      //  but bottom is still in the viewport.
+
+      if (tableWrapperRect.top < editorAreaRect.top && tableWrapperRect.bottom > editorAreaRect.top && isHeaderValid) {
+        return true;
+      } // if the sticky header is below the editor area make it non-sticky
+
+
+      if (stickyHeaderRect.top > editorAreaRect.top) {
+        return false;
+      } // otherwise make it non-sticky
+
+
+      return false;
+    });
+
+    _defineProperty(this, "makeHeaderRowSticky", function (tree) {
+      // If header row height is more than 50% of viewport height don't do this
+      if (_this.stickyRowHeight && _this.stickyRowHeight > window.innerHeight / 2) {
+        return;
+      }
+
+      var table = tree.table;
+
+      var currentTableTop = _this.getCurrentTableTop(tree);
+
+      var domTop = currentTableTop > 0 ? _this.topPosEditorElement : _this.topPosEditorElement + currentTableTop;
+
+      if (!_this.isSticky) {
+        syncStickyRowToTable(table);
+
+        _this.dom.classList.add('sticky');
+
+        table.classList.add(ClassName.TABLE_STICKY);
+        _this.isSticky = true;
+      }
+
+      _this.dom.style.top = "".concat(domTop, "px");
+      updateTableMargin(table);
+
+      _this.emitOn(domTop, _this.colControlsOffset);
+    });
+
+    _defineProperty(this, "makeRowHeaderNotSticky", function (table) {
+      var isEditorDestroyed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+      if (!_this.isSticky || !table || !_this.dom) {
+        return;
+      }
+
+      _this.dom.style.removeProperty('width');
+
+      _this.dom.classList.remove('sticky');
+
+      table.classList.remove(ClassName.TABLE_STICKY);
+      _this.isSticky = false;
+      _this.dom.style.top = '';
+      table.style.removeProperty('margin-top');
+
+      _this.emitOff(isEditorDestroyed);
+    });
+
+    _defineProperty(this, "getWrapperoffset", function () {
+      var inverse = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      var focusValue = inverse ? !_this.focused : _this.focused;
+      return focusValue ? 0 : tableControlsSpacing;
+    });
+
+    _defineProperty(this, "getWrapperRefTop", function (wrapper) {
+      return Math.round(getTop(wrapper)) + _this.getWrapperoffset();
+    });
+
+    _defineProperty(this, "getScrolledTableTop", function (wrapper) {
+      return _this.getWrapperRefTop(wrapper) - _this.topPosEditorElement;
+    });
+
+    _defineProperty(this, "getCurrentTableTop", function (tree) {
+      return _this.getScrolledTableTop(tree.wrapper) + tree.table.clientHeight;
+    });
+
+    _defineProperty(this, "padding", 0);
+
+    _defineProperty(this, "top", 0);
+
+    _defineProperty(this, "emitOn", function (top, padding) {
+      if (top === _this.top && padding === _this.padding) {
+        return;
+      }
+
+      _this.top = top;
+      _this.padding = padding;
+      updateStickyState({
+        pos: _this.getPos(),
+        top: top,
+        sticky: true,
+        padding: padding
+      })(_this.view.state, _this.view.dispatch, _this.view);
+    });
+
+    _defineProperty(this, "emitOff", function (isEditorDestroyed) {
+      if (_this.top === 0 && _this.padding === 0) {
+        return;
+      }
+
+      _this.top = 0;
+      _this.padding = 0;
+
+      if (!isEditorDestroyed) {
+        updateStickyState({
+          pos: _this.getPos(),
+          sticky: false,
+          top: _this.top,
+          padding: _this.padding
+        })(_this.view.state, _this.view.dispatch, _this.view);
+      }
+    });
+
+    this.view = view;
+    this.node = node;
+    this.getPos = getPos;
+    this.eventDispatcher = eventDispatcher;
+    this.dom = document.createElement('tr');
+    this.contentDOM = this.dom;
+    var featureFlags = getEditorFeatureFlags();
+    var stickyHeadersOptimization = featureFlags.stickyHeadersOptimization;
+    this.stickyHeadersOptimization = !!stickyHeadersOptimization;
+    this.lastTimePainted = 0;
+    this.isHeaderRow = supportedHeaderRow(node);
+    this.isSticky = false;
+    this.isTableInit = false;
+
+    if (this.isHeaderRow) {
+      this.dom.setAttribute('data-header-row', 'true');
+      this.subscribe();
+    }
+  }
+  /* external events */
+
+
+  _createClass(TableRowNodeView, [{
+    key: "tree",
+    get: // this is the sticky header table row
+    function get() {
+      return getTree(this.dom);
+    }
+  }, {
+    key: "subscribe",
+    value: function subscribe() {
+      this.editorScrollableElement = findOverflowScrollParent(this.view.dom) || window;
+
+      if (this.editorScrollableElement) {
+        if (this.stickyHeadersOptimization) {
+          this.initObservers();
+        } else {
+          this.editorScrollableElement.addEventListener('scroll', this.onScroll);
+        }
+
+        this.topPosEditorElement = getTop(this.editorScrollableElement);
+      }
+
+      this.eventDispatcher.on('widthPlugin', this.onWidthPluginState);
+      this.eventDispatcher.on(tablePluginKey.key, this.onTablePluginState);
+      this.listening = true;
+      this.dom.addEventListener('wheel', this.headerRowMouseScroll.bind(this));
+      this.dom.addEventListener('touchmove', this.headerRowMouseScroll.bind(this));
+    }
+  }, {
+    key: "unsubscribe",
+    value: function unsubscribe() {
+      if (!this.listening) {
+        return;
+      }
+
+      if (this.intersectionObserver) {
+        this.intersectionObserver.disconnect();
+      }
+
+      if (this.resizeObserver) {
+        this.resizeObserver.disconnect();
+      }
+
+      if (this.editorScrollableElement && !this.stickyHeadersOptimization) {
+        this.editorScrollableElement.removeEventListener('scroll', this.onScroll);
+      }
+
+      this.eventDispatcher.off('widthPlugin', this.onWidthPluginState);
+      this.eventDispatcher.off(tablePluginKey.key, this.onTablePluginState);
+      this.listening = false;
+      this.dom.removeEventListener('wheel', this.headerRowMouseScroll);
+      this.dom.removeEventListener('touchmove', this.headerRowMouseScroll);
+    } // initialize intersection observer to track if table is within scroll area
+
+  }, {
+    key: "initObservers",
+    value: function initObservers() {
+      var _this2 = this;
+
+      if (!this.dom || this.dom.dataset.isObserved) {
+        return;
+      }
+
+      this.dom.dataset.isObserved = 'true';
+      this.createIntersectionObserver();
+      this.createResizeObserver();
+
+      if (!this.intersectionObserver || !this.resizeObserver) {
+        return;
+      }
+
+      this.resizeObserver.observe(this.dom);
+      window.requestAnimationFrame(function () {
+        var _this2$tree;
+
+        // we expect tree to be defined after animation frame
+        var tableContainer = (_this2$tree = _this2.tree) === null || _this2$tree === void 0 ? void 0 : _this2$tree.wrapper.closest(".".concat(TableCssClassName.NODEVIEW_WRAPPER));
+
+        if (tableContainer) {
+          _this2.sentinels.top = tableContainer.getElementsByClassName(ClassName.TABLE_STICKY_SENTINEL_TOP).item(0);
+          _this2.sentinels.bottom = tableContainer.getElementsByClassName(ClassName.TABLE_STICKY_SENTINEL_BOTTOM).item(0);
+          [_this2.sentinels.top, _this2.sentinels.bottom].forEach(function (el) {
+            // skip if already observed for another row on this table
+            if (el && !el.dataset.isObserved) {
+              el.dataset.isObserved = 'true';
+
+              _this2.intersectionObserver.observe(el);
+            }
+          });
+        }
+      });
+    } // updating bottom sentinel position if sticky header height changes
+    // to allocate for new header height
+
+  }, {
+    key: "createResizeObserver",
+    value: function createResizeObserver() {
+      var _this3 = this;
+
+      this.resizeObserver = new ResizeObserver(function (entries) {
+        if (!_this3.tree) {
+          return;
+        }
+
+        var table = _this3.tree.table;
+        entries.forEach(function (entry) {
+          var newHeight = entry.contentRect ? entry.contentRect.height : entry.target.offsetHeight;
+
+          if (_this3.sentinels.bottom && // When the table header is sticky, it would be taller by a 1px (border-bottom),
+          // So we adding this check to allow a 1px difference.
+          Math.abs(newHeight - (_this3.stickyRowHeight || 0)) > stickyHeaderBorderBottomWidth) {
+            _this3.stickyRowHeight = newHeight;
+            _this3.sentinels.bottom.style.bottom = "".concat(tableScrollbarOffset + stickyRowOffsetTop + newHeight, "px");
+            updateTableMargin(table);
+          }
+        });
+      });
+    }
+  }, {
+    key: "createIntersectionObserver",
+    value: function createIntersectionObserver() {
+      var _this4 = this;
+
+      this.intersectionObserver = new IntersectionObserver(function (entries, _) {
+        if (!_this4.tree) {
+          return;
+        }
+
+        var table = _this4.tree.table;
+        entries.forEach(function (entry) {
+          var _entry$rootBounds;
+
+          var target = entry.target; // if the rootBounds has 0 height, e.g. confluence preview mode, we do nothing.
+
+          if (((_entry$rootBounds = entry.rootBounds) === null || _entry$rootBounds === void 0 ? void 0 : _entry$rootBounds.height) === 0) {
+            return;
+          }
+
+          if (target.classList.contains(ClassName.TABLE_STICKY_SENTINEL_TOP)) {
+            var _entry$rootBounds2;
+
+            var sentinelIsBelowScrollArea = (((_entry$rootBounds2 = entry.rootBounds) === null || _entry$rootBounds2 === void 0 ? void 0 : _entry$rootBounds2.bottom) || 0) < entry.boundingClientRect.bottom;
+
+            if (!entry.isIntersecting && !sentinelIsBelowScrollArea) {
+              _this4.tree && _this4.makeHeaderRowSticky(_this4.tree);
+            } else {
+              table && _this4.makeRowHeaderNotSticky(table);
+            }
+          }
+
+          if (target.classList.contains(ClassName.TABLE_STICKY_SENTINEL_BOTTOM)) {
+            var _entry$rootBounds3;
+
+            var sentinelIsAboveScrollArea = entry.boundingClientRect.top - _this4.dom.offsetHeight < (((_entry$rootBounds3 = entry.rootBounds) === null || _entry$rootBounds3 === void 0 ? void 0 : _entry$rootBounds3.top) || 0);
+
+            if (table && !entry.isIntersecting && sentinelIsAboveScrollArea) {
+              _this4.makeRowHeaderNotSticky(table);
+            } else if (entry.isIntersecting && sentinelIsAboveScrollArea) {
+              _this4.tree && _this4.makeHeaderRowSticky(_this4.tree);
+            }
+          }
+        });
+      }, {
+        root: this.editorScrollableElement
+      });
+    }
+    /* paint/update loop */
+
+  }, {
+    key: "update",
+    value:
+    /* nodeview lifecycle */
+    function update(node) {
+      // do nothing if nodes were identical
+      if (node === this.node) {
+        return true;
+      } // see if we're changing into a header row or
+      // changing away from one
+
+
+      var newNodeisHeaderRow = supportedHeaderRow(node);
+
+      if (this.isHeaderRow !== newNodeisHeaderRow) {
+        return false; // re-create nodeview
+      } // node is different but no need to re-create nodeview
+
+
+      this.node = node; // don't do anything if we're just a regular tr
+
+      if (!this.isHeaderRow) {
+        return true;
+      } // something changed, sync widths
+
+
+      var tbody = this.dom.parentElement;
+      var table = tbody && tbody.parentElement;
+      syncStickyRowToTable(table);
+      return true;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.unsubscribe();
+
+      if (this.tree) {
+        this.makeRowHeaderNotSticky(this.tree.table, true);
+      }
+
+      this.emitOff(true);
+    }
+  }, {
+    key: "ignoreMutation",
+    value: function ignoreMutation(mutationRecord) {
+      /* tableRows are not directly editable by the user
+       * so it should be safe to ignore mutations that we cause
+       * by updating styles and classnames on this DOM element
+       *
+       * Update: should not ignore mutations for row selection to avoid known issue with table selection highlight in firefox
+       * Related bug report: https://bugzilla.mozilla.org/show_bug.cgi?id=1289673
+       * */
+      var isTableSelection = mutationRecord.type === 'selection' && mutationRecord.target.nodeName === 'TR';
+      /**
+       * Update: should not ignore mutations when an node is added, as this interferes with
+       * prosemirrors handling of some language inputs in Safari (ie. Pinyin, Hiragana).
+       *
+       * In paticular, when a composition occurs at the start of the first node inside a table cell, if the resulting mutation
+       * from the composition end is ignored than prosemirror will end up with; invalid table markup nesting and a misplaced
+       * selection and insertion.
+       */
+
+      var isNodeInsertion = mutationRecord.type === 'childList' && mutationRecord.target.nodeName === 'TR' && mutationRecord.addedNodes.length;
+
+      if (isTableSelection || isNodeInsertion) {
+        return false;
+      }
+
+      return true;
+    }
+    /* receive external events */
+
+  }]);
+
+  return TableRowNodeView;
+}();

package/dist/esm/plugins/table/pm-plugins/sticky-headers/plugin-key.js

@@ -0,0 +1,2 @@
+import { PluginKey } from 'prosemirror-state';
+export var pluginKey = new PluginKey('stickyHeadersPlugin');

package/dist/esm/plugins/table/pm-plugins/sticky-headers/plugin-state.js

@@ -0,0 +1,57 @@
+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; }
+
+import { pluginFactory } from '@atlaskit/editor-common/utils';
+import { pluginKey } from './plugin-key';
+
+var reducer = function reducer(pluginState, action) {
+  if (action.name === 'UPDATE') {
+    var updated = false;
+    var updatedState = pluginState.map(function (oldTableState) {
+      var replace = oldTableState.pos === action.state.pos;
+
+      if (replace) {
+        updated = true;
+      }
+
+      return replace ? action.state : oldTableState;
+    });
+
+    if (!updated) {
+      // new, add it
+      updatedState.push(action.state);
+    }
+
+    return updatedState;
+  } else if (action.name === 'REMOVE') {
+    return pluginState.filter(function (rowState) {
+      return rowState.pos !== action.pos;
+    });
+  }
+
+  return pluginState;
+};
+
+var _pluginFactory = pluginFactory(pluginKey, reducer, {
+  mapping: function mapping(tr, pluginState) {
+    if (tr.docChanged) {
+      return pluginState.map(function (rowInfo) {
+        var remapped = tr.mapping.mapResult(rowInfo.pos);
+        return remapped ? _objectSpread(_objectSpread({}, rowInfo), {}, {
+          pos: remapped.pos
+        }) : undefined;
+      }).filter(function (f) {
+        return f !== undefined;
+      });
+    }
+
+    return pluginState;
+  }
+}),
+    createPluginState = _pluginFactory.createPluginState,
+    createCommand = _pluginFactory.createCommand;
+
+export { createPluginState, createCommand };

package/dist/esm/plugins/table/pm-plugins/sticky-headers/plugin.js

@@ -0,0 +1,21 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { TableRowNodeView } from './nodeviews/tableRow';
+import { pluginKey } from './plugin-key';
+import { createPluginState } from './plugin-state';
+export var createPlugin = function createPlugin(dispatch, eventDispatcher) {
+  var initialState = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {
+    return [];
+  };
+  var getEditorFeatureFlags = arguments.length > 3 ? arguments[3] : undefined;
+  return new SafePlugin({
+    state: createPluginState(dispatch, initialState),
+    key: pluginKey,
+    props: {
+      nodeViews: {
+        tableRow: function tableRow(node, view, getPos) {
+          return new TableRowNodeView(node, view, getPos, eventDispatcher, getEditorFeatureFlags);
+        }
+      }
+    }
+  });
+};

package/dist/esm/plugins/table/pm-plugins/sticky-headers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/plugins/table/pm-plugins/sticky-headers/util.js

@@ -0,0 +1,16 @@
+// only worry about the first row for now
+export var findStickyHeaderForTable = function findStickyHeaderForTable(state, tablePos) {
+  if (!state || tablePos === undefined) {
+    return undefined;
+  }
+
+  var rowInfo = state.find(function (rowInfo) {
+    return rowInfo.pos === tablePos + 1;
+  });
+
+  if (!rowInfo) {
+    return undefined;
+  }
+
+  return rowInfo.sticky ? rowInfo : undefined;
+};