@lexical/table 0.1.14 → 0.1.17

package/LexicalTable.dev.js

@@ -7,48 +7,51 @@
 'use strict';
 
 var lexical = require('lexical');
-
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * 
- */
-function addClassNamesToElement(element, ...classNames) {
-  classNames.forEach(className => {
-    if (className != null && typeof className === 'string') {
-      element.classList.add(...className.split(' '));
-    }
-  });
-}
-
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * 
- */
+var utils = require('@lexical/utils');
+
+/* eslint-disable sort-keys-fix/sort-keys-fix */
+const TableCellHeaderStates = {
+  NO_STATUS: 0,
+  ROW: 1,
+  COLUMN: 2,
+  BOTH: 3
+};
 class TableCellNode extends lexical.GridCellNode {
   static getType() {
     return 'tablecell';
   }
 
   static clone(node) {
-    return new TableCellNode(new Set(node.__headerStyles), node.__colSpan, node.__key);
+    return new TableCellNode(node.__headerState, node.__colSpan, node.__width, node.__key);
   }
 
-  constructor(headerStyles, colSpan = 1, key) {
+  static convertDOM() {
+    return {
+      td: node => ({
+        conversion: convertTableCellNodeElement,
+        priority: 0
+      }),
+      th: node => ({
+        conversion: convertTableCellNodeElement,
+        priority: 0
+      })
+    };
+  }
+
+  constructor(headerState = TableCellHeaderStates.NO_STATUS, colSpan = 1, width, key) {
     super(colSpan, key);
-    this.__headerStyles = headerStyles || new Set();
+    this.__headerState = headerState;
+    this.__width = width;
   }
 
   createDOM(config) {
     const element = document.createElement(this.getTag());
-    addClassNamesToElement(element, config.theme.tableCell, this.hasHeader() && config.theme.TableCellHeaderStyles);
+
+    if (this.__width) {
+      element.style.width = `${this.__width}px`;
+    }
+
+    utils.addClassNamesToElement(element, config.theme.tableCell, this.hasHeader() && config.theme.tableCellHeader);
     return element;
   }
 
@@ -56,38 +59,49 @@ class TableCellNode extends lexical.GridCellNode {
     return this.hasHeader() ? 'th' : 'td';
   }
 
-  setHeaderStyles(headerStyles) {
+  setHeaderStyles(headerState) {
     const self = this.getWritable();
-    self.__headerStyles = new Set(headerStyles);
-    return this.__headerStyles;
+    self.__headerState = headerState;
+    return this.__headerState;
   }
 
   getHeaderStyles() {
-    return this.getLatest().__headerStyles;
+    return this.getLatest().__headerState;
+  }
+
+  setWidth(width) {
+    const self = this.getWritable();
+    self.__width = width;
+    return this.__width;
+  }
+
+  getWidth() {
+    return this.getLatest().__width;
   }
 
-  toggleHeaderStyle(key) {
+  toggleHeaderStyle(headerStateToToggle) {
     const self = this.getWritable();
-    const newHeaderValue = self.getHeaderStyles();
 
-    if (newHeaderValue.has(key)) {
-      newHeaderValue.delete(key);
+    if ((self.__headerState & headerStateToToggle) === headerStateToToggle) {
+      self.__headerState -= headerStateToToggle;
     } else {
-      newHeaderValue.add(key);
+      self.__headerState += headerStateToToggle;
     }
 
-    self.__headerStyles = new Set(newHeaderValue);
+    self.__headerState = self.__headerState;
     return self;
   }
 
-  hasHeader() {
-    const headerStyles = this.getLatest().__headerStyles;
+  hasHeaderState(headerState) {
+    return (this.getHeaderStyles() & headerState) === headerState;
+  }
 
-    return headerStyles.size > 0;
+  hasHeader() {
+    return this.getLatest().__headerState !== TableCellHeaderStates.NO_STATUS;
   }
 
   updateDOM(prevNode) {
-    return prevNode.__headerStyles.size !== this.__headerStyles.size;
+    return prevNode.__headerState !== this.__headerState || prevNode.__width !== this.__width;
   }
 
   collapseAtStart() {
@@ -99,8 +113,29 @@ class TableCellNode extends lexical.GridCellNode {
   }
 
 }
-function $createTableCellNode(headerStyles) {
-  return new TableCellNode(headerStyles);
+function convertTableCellNodeElement(domNode) {
+  const nodeName = domNode.nodeName.toLowerCase();
+  const tableCellNode = $createTableCellNode(nodeName === 'th' ? TableCellHeaderStates.ROW : TableCellHeaderStates.NO_STATUS);
+  return {
+    node: tableCellNode,
+    forChild: (lexicalNode, parentLexicalNode) => {
+      if ($isTableCellNode(parentLexicalNode) && !lexical.$isElementNode(lexicalNode)) {
+        const paragraphNode = lexical.$createParagraphNode();
+
+        if (lexical.$isLineBreakNode(lexicalNode) && lexicalNode.getTextContent() === '\n') {
+          return null;
+        }
+
+        paragraphNode.append(lexicalNode);
+        return paragraphNode;
+      }
+
+      return lexicalNode;
+    }
+  };
+}
+function $createTableCellNode(headerState, colSpan = 1, width) {
+  return new TableCellNode(headerState, colSpan, width);
 }
 function $isTableCellNode(node) {
   return node instanceof TableCellNode;
@@ -114,18 +149,273 @@ function $isTableCellNode(node) {
  *
  * 
  */
-function $findMatchingParent(startingNode, findFn) {
-  let curr = startingNode;
+const getSelection = () => window.getSelection();
 
-  while (curr !== lexical.$getRoot() && curr != null) {
-    if (findFn(curr)) {
-      return curr;
-    }
+var getDOMSelection = getSelection;
 
-    curr = curr.getParent();
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+const removeHighlightStyle = document.createElement('style');
+removeHighlightStyle.appendChild(document.createTextNode('::selection{background-color: transparent}'));
+class TableSelection {
+  constructor(editor, tableNodeKey) {
+    this.isHighlightingCells = false;
+    this.startX = -1;
+    this.startY = -1;
+    this.currentX = -1;
+    this.currentY = -1;
+    this.listenersToRemove = new Set();
+    this.tableNodeKey = tableNodeKey;
+    this.editor = editor;
+    this.grid = {
+      cells: [],
+      columns: 0,
+      rows: 0
+    };
+    this.gridSelection = null;
+    this.anchorCellNodeKey = null;
+    this.focusCellNodeKey = null;
+    this.anchorCell = null;
+    this.focusCell = null;
+    this.trackTableGrid();
+  }
+
+  getGrid() {
+    return this.grid;
+  }
+
+  removeListeners() {
+    Array.from(this.listenersToRemove).forEach(removeListener => removeListener());
+  }
+
+  trackTableGrid() {
+    const observer = new MutationObserver(records => {
+      this.editor.update(() => {
+        let gridNeedsRedraw = false;
+
+        for (let i = 0; i < records.length; i++) {
+          const record = records[i];
+          const target = record.target;
+          const nodeName = target.nodeName;
+
+          if (nodeName === 'TABLE' || nodeName === 'TR') {
+            gridNeedsRedraw = true;
+            break;
+          }
+        }
+
+        if (!gridNeedsRedraw) {
+          return;
+        }
+
+        const tableElement = this.editor.getElementByKey(this.tableNodeKey);
+
+        if (!tableElement) {
+          throw new Error('Expected to find TableElement in DOM');
+        }
+
+        this.grid = getTableGrid(tableElement);
+      });
+    });
+    this.editor.update(() => {
+      const tableElement = this.editor.getElementByKey(this.tableNodeKey);
+
+      if (!tableElement) {
+        throw new Error('Expected to find TableElement in DOM');
+      }
+
+      this.grid = getTableGrid(tableElement);
+      observer.observe(tableElement, {
+        childList: true,
+        subtree: true
+      });
+    });
+  }
+
+  clearHighlight() {
+    this.editor.update(() => {
+      const tableNode = lexical.$getNodeByKey(this.tableNodeKey);
+
+      if (!$isTableNode(tableNode)) {
+        throw new Error('Expected TableNode.');
+      }
+
+      const tableElement = this.editor.getElementByKey(this.tableNodeKey);
+
+      if (!tableElement) {
+        throw new Error('Expected to find TableElement in DOM');
+      }
+
+      const grid = getTableGrid(tableElement);
+      this.isHighlightingCells = false;
+      this.startX = -1;
+      this.startY = -1;
+      this.currentX = -1;
+      this.currentY = -1;
+      this.gridSelection = null;
+      this.anchorCellNodeKey = null;
+      this.focusCellNodeKey = null;
+      this.anchorCell = null;
+      this.focusCell = null;
+      $updateDOMForSelection(grid, null);
+      lexical.$setSelection(null);
+      this.editor.dispatchCommand(lexical.SELECTION_CHANGE_COMMAND);
+      const parent = removeHighlightStyle.parentNode;
+
+      if (parent != null) {
+        parent.removeChild(removeHighlightStyle);
+      }
+    });
+  }
+
+  adjustFocusCellForSelection(cell, ignoreStart = false) {
+    this.editor.update(() => {
+      const tableNode = lexical.$getNodeByKey(this.tableNodeKey);
+
+      if (!$isTableNode(tableNode)) {
+        throw new Error('Expected TableNode.');
+      }
+
+      const tableElement = this.editor.getElementByKey(this.tableNodeKey);
+
+      if (!tableElement) {
+        throw new Error('Expected to find TableElement in DOM');
+      }
+
+      const cellX = cell.x;
+      const cellY = cell.y;
+      this.focusCell = cell;
+      const domSelection = getDOMSelection();
+
+      if (this.anchorCell !== null) {
+        // Collapse the selection
+        domSelection.setBaseAndExtent(this.anchorCell.elem, 0, cell.elem, 0);
+      }
+
+      if (!this.isHighlightingCells && (this.startX !== cellX || this.startY !== cellY || ignoreStart)) {
+        this.isHighlightingCells = true;
+
+        if (document.body) {
+          document.body.appendChild(removeHighlightStyle);
+        }
+      } else if (cellX === this.currentX && cellY === this.currentY) {
+        return;
+      }
+
+      this.currentX = cellX;
+      this.currentY = cellY;
+
+      if (this.isHighlightingCells) {
+        const focusTableCellNode = lexical.$getNearestNodeFromDOMNode(cell.elem);
+
+        if (this.gridSelection != null && this.anchorCellNodeKey != null && $isTableCellNode(focusTableCellNode)) {
+          const focusNodeKey = focusTableCellNode.getKey();
+          this.gridSelection = lexical.$createGridSelection();
+          this.focusCellNodeKey = focusNodeKey;
+          this.gridSelection.set(this.tableNodeKey, // $FlowFixMe This is not null, as you can see in the statement above.
+          this.anchorCellNodeKey, this.focusCellNodeKey);
+          lexical.$setSelection(this.gridSelection);
+          this.editor.dispatchCommand(lexical.SELECTION_CHANGE_COMMAND);
+          $updateDOMForSelection(this.grid, this.gridSelection);
+        }
+      }
+    });
+  }
+
+  setAnchorCellForSelection(cell) {
+    this.editor.update(() => {
+      this.anchorCell = cell;
+      this.startX = cell.x;
+      this.startY = cell.y;
+      const domSelection = getDOMSelection();
+      domSelection.setBaseAndExtent(cell.elem, 0, cell.elem, 0);
+      const anchorTableCellNode = lexical.$getNearestNodeFromDOMNode(cell.elem);
+
+      if ($isTableCellNode(anchorTableCellNode)) {
+        const anchorNodeKey = anchorTableCellNode.getKey();
+        this.gridSelection = lexical.$createGridSelection();
+        this.anchorCellNodeKey = anchorNodeKey;
+      }
+    });
+  }
+
+  formatCells(type) {
+    this.editor.update(() => {
+      const selection = lexical.$getSelection();
+
+      if (!lexical.$isGridSelection(selection)) {
+        {
+          throw Error(`Expected grid selection`);
+        }
+      } // This is to make Flow play ball.
+
+
+      const formatSelection = lexical.$createRangeSelection();
+      const anchor = formatSelection.anchor;
+      const focus = formatSelection.focus;
+      selection.getNodes().forEach(cellNode => {
+        if ($isTableCellNode(cellNode) && cellNode.getTextContentSize() !== 0) {
+          anchor.set(cellNode.getKey(), 0, 'element');
+          focus.set(cellNode.getKey(), cellNode.getChildrenSize(), 'element');
+          formatSelection.formatText(type);
+        }
+      });
+      lexical.$setSelection(selection);
+      this.editor.dispatchCommand(lexical.SELECTION_CHANGE_COMMAND);
+    });
+  }
+
+  clearText() {
+    this.editor.update(() => {
+      const tableNode = lexical.$getNodeByKey(this.tableNodeKey);
+
+      if (!$isTableNode(tableNode)) {
+        throw new Error('Expected TableNode.');
+      }
+
+      const selection = lexical.$getSelection();
+
+      if (!lexical.$isGridSelection(selection)) {
+        {
+          throw Error(`Expected grid selection`);
+        }
+      }
+
+      const selectedNodes = selection.getNodes().filter($isTableCellNode);
+
+      if (selectedNodes.length === this.grid.columns * this.grid.rows) {
+        tableNode.selectPrevious(); // Delete entire table
+
+        tableNode.remove();
+        this.clearHighlight();
+        return;
+      }
+
+      selectedNodes.forEach(cellNode => {
+        if (lexical.$isElementNode(cellNode)) {
+          const paragraphNode = lexical.$createParagraphNode();
+          const textNode = lexical.$createTextNode();
+          paragraphNode.append(textNode);
+          cellNode.append(paragraphNode);
+          cellNode.getChildren().forEach(child => {
+            if (child !== paragraphNode) {
+              child.remove();
+            }
+          });
+        }
+      });
+      $updateDOMForSelection(this.grid, null);
+      lexical.$setSelection(null);
+      this.editor.dispatchCommand(lexical.SELECTION_CHANGE_COMMAND);
+    });
   }
 
-  return null;
 }
 
 /**
@@ -136,22 +426,404 @@ function $findMatchingParent(startingNode, findFn) {
  *
  * 
  */
-const getSelection = () => window.getSelection();
+const CriticalPriority = 4;
+const LEXICAL_ELEMENT_KEY = '__lexicalTableSelection';
+function applyTableHandlers(tableNode, tableElement, editor) {
+  const rootElement = editor.getRootElement();
+
+  if (rootElement === null) {
+    throw new Error('No root element.');
+  }
+
+  const tableSelection = new TableSelection(editor, tableNode.getKey());
+  attachTableSelectionToTableElement(tableElement, tableSelection);
+  let isMouseDown = false;
+  tableElement.addEventListener('dblclick', event => {
+    // $FlowFixMe: event.target is always a Node on the DOM
+    const cell = getCellFromTarget(event.target);
+
+    if (cell !== null) {
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      event.stopPropagation();
+      tableSelection.setAnchorCellForSelection(cell);
+      tableSelection.adjustFocusCellForSelection(cell, true);
+      isMouseDown = false;
+    }
+  }); // This is the anchor of the selection.
+
+  tableElement.addEventListener('mousedown', event => {
+    setTimeout(() => {
+      if (event.button !== 0) {
+        return;
+      } // $FlowFixMe: event.target is always a Node on the DOM
+
+
+      const cell = getCellFromTarget(event.target);
+
+      if (cell !== null) {
+        isMouseDown = true;
+        tableSelection.setAnchorCellForSelection(cell);
+        document.addEventListener('mouseup', () => {
+          isMouseDown = false;
+        }, {
+          capture: true,
+          once: true
+        });
+      }
+    }, 0);
+  }); // This is adjusting the focus of the selection.
+
+  tableElement.addEventListener('mousemove', event => {
+    if (isMouseDown) {
+      // $FlowFixMe: event.target is always a Node on the DOM
+      const cell = getCellFromTarget(event.target);
+
+      if (cell !== null) {
+        const cellX = cell.x;
+        const cellY = cell.y;
+
+        if (isMouseDown && (tableSelection.startX !== cellX || tableSelection.startY !== cellY || tableSelection.isHighlightingCells)) {
+          event.preventDefault();
+          isMouseDown = true;
+          tableSelection.adjustFocusCellForSelection(cell);
+        }
+      }
+    }
+  });
+  tableElement.addEventListener('mouseup', event => {
+    if (isMouseDown) {
+      isMouseDown = false;
+    }
+  }); // Select entire table at this point, when grid selection is ready.
+
+  tableElement.addEventListener('mouseleave', event => {
+    if (isMouseDown) {
+      return;
+    }
+  }); // Clear selection when clicking outside of dom.
+
+  const mouseDownCallback = event => {
+    if (event.button !== 0) {
+      return;
+    }
+
+    editor.update(() => {
+      const selection = lexical.$getSelection();
+
+      if (lexical.$isGridSelection(selection) && selection.gridKey === tableSelection.tableNodeKey && rootElement.contains(event.target)) {
+        return tableSelection.clearHighlight();
+      }
+    });
+  };
+
+  window.addEventListener('mousedown', mouseDownCallback);
+  tableSelection.listenersToRemove.add(() => window.removeEventListener('mousedown', mouseDownCallback));
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.KEY_ARROW_DOWN_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+    const event = payload;
+    const direction = 'down';
+
+    if (lexical.$isRangeSelection(selection)) {
+      if (selection.isCollapsed()) {
+        const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+        if (!$isTableCellNode(tableCellNode)) {
+          return false;
+        }
+
+        const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+        const elementParentNode = utils.$findMatchingParent(selection.anchor.getNode(), n => lexical.$isElementNode(n));
+
+        if (elementParentNode == null) {
+          throw new Error('Expected BlockNode Parent');
+        }
+
+        const lastChild = tableCellNode.getLastChild();
+        const isSelectionInLastBlock = lastChild && elementParentNode.isParentOf(lastChild) || elementParentNode === lastChild;
+
+        if (isSelectionInLastBlock || event.shiftKey) {
+          event.preventDefault();
+          event.stopImmediatePropagation();
+          event.stopPropagation(); // Start Selection
+
+          if (event.shiftKey) {
+            tableSelection.setAnchorCellForSelection(tableNode.getCellFromCordsOrThrow(currentCords.x, currentCords.y, tableSelection.grid));
+            return adjustFocusNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+          }
+
+          return selectGridNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+        }
+      }
+    } else if (lexical.$isGridSelection(selection) && event.shiftKey) {
+      const tableCellNode = selection.focus.getNode();
+
+      if (!$isTableCellNode(tableCellNode)) {
+        return false;
+      }
+
+      const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      event.stopPropagation();
+      return adjustFocusNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+    }
+
+    return false;
+  }, CriticalPriority));
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.KEY_ARROW_UP_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+    const event = payload;
+    const direction = 'up';
+
+    if (lexical.$isRangeSelection(selection)) {
+      if (selection.isCollapsed()) {
+        const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+        if (!$isTableCellNode(tableCellNode)) {
+          return false;
+        }
+
+        const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+        const elementParentNode = utils.$findMatchingParent(selection.anchor.getNode(), n => lexical.$isElementNode(n));
+
+        if (elementParentNode == null) {
+          throw new Error('Expected BlockNode Parent');
+        }
+
+        const lastChild = tableCellNode.getLastChild();
+        const isSelectionInLastBlock = lastChild && elementParentNode.isParentOf(lastChild) || elementParentNode === lastChild;
+
+        if (isSelectionInLastBlock || event.shiftKey) {
+          event.preventDefault();
+          event.stopImmediatePropagation();
+          event.stopPropagation(); // Start Selection
+
+          if (event.shiftKey) {
+            tableSelection.setAnchorCellForSelection(tableNode.getCellFromCordsOrThrow(currentCords.x, currentCords.y, tableSelection.grid));
+            return adjustFocusNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+          }
+
+          return selectGridNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+        }
+      }
+    } else if (lexical.$isGridSelection(selection) && event.shiftKey) {
+      const tableCellNode = selection.focus.getNode();
+
+      if (!$isTableCellNode(tableCellNode)) {
+        return false;
+      }
+
+      const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      event.stopPropagation();
+      return adjustFocusNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+    }
+
+    return false;
+  }, CriticalPriority));
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.KEY_ARROW_LEFT_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+    const event = payload;
+    const direction = 'backward';
+
+    if (lexical.$isRangeSelection(selection)) {
+      if (selection.isCollapsed()) {
+        const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+        if (!$isTableCellNode(tableCellNode)) {
+          return false;
+        }
+
+        const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+        const elementParentNode = utils.$findMatchingParent(selection.anchor.getNode(), n => lexical.$isElementNode(n));
+
+        if (elementParentNode == null) {
+          throw new Error('Expected BlockNode Parent');
+        }
+
+        if (selection.anchor.offset === 0 || event.shiftKey) {
+          event.preventDefault();
+          event.stopImmediatePropagation();
+          event.stopPropagation(); // Start Selection
+
+          if (event.shiftKey) {
+            tableSelection.setAnchorCellForSelection(tableNode.getCellFromCordsOrThrow(currentCords.x, currentCords.y, tableSelection.grid));
+            return adjustFocusNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+          }
+
+          return selectGridNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+        }
+      }
+    } else if (lexical.$isGridSelection(selection) && event.shiftKey) {
+      const tableCellNode = selection.focus.getNode();
+
+      if (!$isTableCellNode(tableCellNode)) {
+        return false;
+      }
+
+      const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      event.stopPropagation();
+      return adjustFocusNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+    }
+
+    return false;
+  }, CriticalPriority));
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.KEY_ARROW_RIGHT_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+    const event = payload;
+    const direction = 'forward';
+
+    if (lexical.$isRangeSelection(selection)) {
+      if (selection.isCollapsed()) {
+        const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+        if (!$isTableCellNode(tableCellNode)) {
+          return false;
+        }
+
+        const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+        const elementParentNode = utils.$findMatchingParent(selection.anchor.getNode(), n => lexical.$isElementNode(n));
+
+        if (elementParentNode == null) {
+          throw new Error('Expected BlockNode Parent');
+        }
+
+        if (selection.anchor.offset === selection.anchor.getNode().getTextContentSize() || event.shiftKey) {
+          event.preventDefault();
+          event.stopImmediatePropagation();
+          event.stopPropagation(); // Start Selection
+
+          if (event.shiftKey) {
+            tableSelection.setAnchorCellForSelection(tableNode.getCellFromCordsOrThrow(currentCords.x, currentCords.y, tableSelection.grid));
+            return adjustFocusNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+          }
+
+          return selectGridNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+        }
+      }
+    } else if (lexical.$isGridSelection(selection) && event.shiftKey) {
+      const tableCellNode = selection.focus.getNode();
+
+      if (!$isTableCellNode(tableCellNode)) {
+        return false;
+      }
+
+      const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      event.stopPropagation();
+      return adjustFocusNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+    }
+
+    return false;
+  }, CriticalPriority));
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.DELETE_CHARACTER_COMMAND, () => {
+    const selection = lexical.$getSelection();
+
+    if (lexical.$isGridSelection(selection)) {
+      tableSelection.clearText();
+      return true;
+    } else if (lexical.$isRangeSelection(selection)) {
+      const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+      if (!$isTableCellNode(tableCellNode)) {
+        return false;
+      }
+
+      if (selection.isCollapsed() && selection.anchor.offset === 0 && selection.anchor.getNode().getPreviousSiblings().length === 0) {
+        return true;
+      }
+    }
+
+    return false;
+  }, CriticalPriority));
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.KEY_BACKSPACE_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (lexical.$isGridSelection(selection)) {
+      const event = payload;
+      event.preventDefault();
+      event.stopPropagation();
+      tableSelection.clearText();
+      return true;
+    } else if (lexical.$isRangeSelection(selection)) {
+      const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+      if (!$isTableCellNode(tableCellNode)) {
+        return false;
+      }
+    }
+
+    return false;
+  }, CriticalPriority));
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.FORMAT_TEXT_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (lexical.$isGridSelection(selection)) {
+      tableSelection.formatCells(payload);
+      return true;
+    } else if (lexical.$isRangeSelection(selection)) {
+      const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+      if (!$isTableCellNode(tableCellNode)) {
+        return false;
+      }
+    }
+
+    return false;
+  }, CriticalPriority));
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.INSERT_TEXT_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (lexical.$isGridSelection(selection)) {
+      tableSelection.clearHighlight();
+      return false;
+    } else if (lexical.$isRangeSelection(selection)) {
+      const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+      if (!$isTableCellNode(tableCellNode)) {
+        return false;
+      }
+    }
+
+    return false;
+  }, CriticalPriority));
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.KEY_TAB_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (lexical.$isRangeSelection(selection)) {
+      const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+      if (!$isTableCellNode(tableCellNode)) {
+        return false;
+      }
 
-var getDOMSelection = getSelection;
+      const event = payload;
 
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * 
- */
-const LowPriority = 1;
-const CriticalPriority = 4;
-const removeHighlightStyle = document.createElement('style');
-removeHighlightStyle.appendChild(document.createTextNode('::selection{background-color: transparent}'));
+      if (selection.isCollapsed()) {
+        const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+        event.preventDefault();
+        selectGridNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, !event.shiftKey ? 'forward' : 'backward');
+        return true;
+      }
+    }
+
+    return false;
+  }, CriticalPriority));
+  return tableSelection;
+}
+function attachTableSelectionToTableElement(tableElement, tableSelection) {
+  // $FlowFixMe
+  tableElement[LEXICAL_ELEMENT_KEY] = tableSelection;
+}
+function getTableSelectionFromTableElement(tableElement) {
+  // $FlowFixMe
+  return tableElement[LEXICAL_ELEMENT_KEY];
+}
 function getCellFromTarget(node) {
   let currentNode = node;
 
@@ -174,108 +846,80 @@ function getCellFromTarget(node) {
 
   return null;
 }
-function trackTableGrid(tableNode, tableElement, editor) {
+function getTableGrid(tableElement) {
   const cells = [];
   const grid = {
     cells,
     columns: 0,
     rows: 0
   };
+  let currentNode = tableElement.firstChild;
+  let x = 0;
+  let y = 0;
+  cells.length = 0;
 
-  const calcSize = () => {
-    let currentNode = tableElement.firstChild;
-    let x = 0;
-    let y = 0;
-    cells.length = 0;
-
-    while (currentNode != null) {
-      const nodeMame = currentNode.nodeName;
-
-      if (nodeMame === 'TD' || nodeMame === 'TH') {
-        // $FlowFixMe: TD is always an HTMLElement
-        const elem = currentNode;
-        const cell = {
-          elem,
-          highlighted: false,
-          x,
-          y
-        }; // $FlowFixMe: internal field
-
-        currentNode._cell = cell;
-
-        if (cells[y] === undefined) {
-          cells[y] = [];
-        }
-
-        cells[y][x] = cell;
-      } else {
-        const child = currentNode.firstChild;
-
-        if (child != null) {
-          currentNode = child;
-          continue;
-        }
+  while (currentNode != null) {
+    const nodeMame = currentNode.nodeName;
+
+    if (nodeMame === 'TD' || nodeMame === 'TH') {
+      // $FlowFixMe: TD is always an HTMLElement
+      const elem = currentNode;
+      const cell = {
+        elem,
+        highlighted: false,
+        x,
+        y
+      }; // $FlowFixMe: internal field
+
+      currentNode._cell = cell;
+
+      if (cells[y] === undefined) {
+        cells[y] = [];
       }
 
-      const sibling = currentNode.nextSibling;
+      cells[y][x] = cell;
+    } else {
+      const child = currentNode.firstChild;
 
-      if (sibling != null) {
-        x++;
-        currentNode = sibling;
+      if (child != null) {
+        currentNode = child;
         continue;
       }
+    }
 
-      const parent = currentNode.parentNode;
-
-      if (parent != null) {
-        const parentSibling = parent.nextSibling;
-
-        if (parentSibling == null) {
-          break;
-        }
+    const sibling = currentNode.nextSibling;
 
-        y++;
-        x = 0;
-        currentNode = parentSibling;
-      }
+    if (sibling != null) {
+      x++;
+      currentNode = sibling;
+      continue;
     }
 
-    grid.columns = x + 1;
-    grid.rows = y + 1;
-    tableNode.setGrid(grid);
-  };
-
-  const observer = new MutationObserver(records => {
-    editor.update(() => {
-      let gridNeedsRedraw = false;
+    const parent = currentNode.parentNode;
 
-      for (let i = 0; i < records.length; i++) {
-        const record = records[i];
-        const target = record.target;
-        const nodeName = target.nodeName;
+    if (parent != null) {
+      const parentSibling = parent.nextSibling;
 
-        if (nodeName === 'TABLE' || nodeName === 'TR') {
-          gridNeedsRedraw = true;
-          break;
-        }
+      if (parentSibling == null) {
+        break;
       }
 
-      if (!gridNeedsRedraw) {
-        return;
-      }
+      y++;
+      x = 0;
+      currentNode = parentSibling;
+    }
+  }
 
-      calcSize();
-    });
-  });
-  observer.observe(tableElement, {
-    childList: true,
-    subtree: true
-  });
-  calcSize();
+  grid.columns = x + 1;
+  grid.rows = y + 1;
   return grid;
 }
-function updateCells(fromX, toX, fromY, toY, cells) {
-  const highlighted = [];
+function $updateDOMForSelection(grid, gridSelection) {
+  const highlightedCells = [];
+  const {
+    cells
+  } = grid;
+  const selectedCellNodes = new Set(gridSelection ? gridSelection.getNodes() : []);
 
   for (let y = 0; y < cells.length; y++) {
     const row = cells[y];
@@ -283,16 +927,14 @@ function updateCells(fromX, toX, fromY, toY, cells) {
     for (let x = 0; x < row.length; x++) {
       const cell = row[x];
       const elemStyle = cell.elem.style;
+      const lexicalNode = lexical.$getNearestNodeFromDOMNode(cell.elem);
 
-      if (x >= fromX && x <= toX && y >= fromY && y <= toY) {
-        if (!cell.highlighted) {
-          cell.highlighted = true;
-          elemStyle.setProperty('background-color', 'rgb(163, 187, 255)');
-          elemStyle.setProperty('caret-color', 'transparent');
-        }
-
-        highlighted.push(cell);
-      } else if (cell.highlighted) {
+      if (lexicalNode && selectedCellNodes.has(lexicalNode)) {
+        cell.highlighted = true;
+        elemStyle.setProperty('background-color', 'rgb(163, 187, 255)');
+        elemStyle.setProperty('caret-color', 'transparent');
+        highlightedCells.push(cell);
+      } else {
         cell.highlighted = false;
         elemStyle.removeProperty('background-color');
         elemStyle.removeProperty('caret-color');
@@ -304,319 +946,103 @@ function updateCells(fromX, toX, fromY, toY, cells) {
     }
   }
 
-  return highlighted;
+  return highlightedCells;
 }
-function $applyCustomTableHandlers(tableNode, tableElement, editor) {
-  const rootElement = editor.getRootElement();
-
-  if (rootElement === null) {
-    throw new Error('No root element.');
-  }
-
-  trackTableGrid(tableNode, tableElement, editor);
-  const grid = tableNode.getGrid();
-  let isSelected = false;
-  let isHighlightingCells = false;
-  let startX = -1;
-  let startY = -1;
-  let currentX = -1;
-  let currentY = -1;
-  let highlightedCells = [];
-  const editorListeners = new Set();
-  let deleteCharacterListener = null;
-
-  if (grid == null) {
-    throw new Error('Table grid not found.');
-  }
-
-  tableElement.addEventListener('mousemove', event => {
-    if (isSelected) {
-      // $FlowFixMe: event.target is always a Node on the DOM
-      const cell = getCellFromTarget(event.target);
-
-      if (cell !== null) {
-        const cellX = cell.x;
-        const cellY = cell.y;
-
-        if (!isHighlightingCells && (startX !== cellX || startY !== cellY)) {
-          event.preventDefault();
-          const domSelection = getDOMSelection();
-          const anchorNode = domSelection.anchorNode;
 
-          if (anchorNode !== null) {
-            // Collapse the selection
-            domSelection.setBaseAndExtent(anchorNode, 0, anchorNode, 0);
-          }
-
-          isHighlightingCells = true;
-
-          if (document.body) {
-            document.body.appendChild(removeHighlightStyle);
-          }
+const selectGridNodeInDirection = (tableSelection, tableNode, x, y, direction) => {
+  switch (direction) {
+    case 'backward':
+    case 'forward':
+      {
+        const isForward = direction === 'forward';
 
-          if (deleteCharacterListener === null) {
-            deleteCharacterListener = editor.addListener('command', (type, payload) => {
-              if (type === 'deleteCharacter') {
-                if (highlightedCells.length === grid.columns * grid.rows) {
-                  tableNode.selectPrevious(); // Delete entire table
-
-                  tableNode.remove();
-                  clearHighlight();
-                  return true;
-                }
-
-                highlightedCells.forEach(({
-                  elem
-                }) => {
-                  const cellNode = lexical.$getNearestNodeFromDOMNode(elem);
-
-                  if (lexical.$isElementNode(cellNode)) {
-                    const paragraphNode = lexical.$createParagraphNode();
-                    const textNode = lexical.$createTextNode();
-                    paragraphNode.append(textNode);
-                    cellNode.append(paragraphNode);
-                    cellNode.getChildren().forEach(child => {
-                      if (child !== paragraphNode) {
-                        child.remove();
-                      }
-                    });
-                  }
-                });
-                tableNode.setSelectionState(null);
-                lexical.$setSelection(null);
-                return true;
-              } else if (type === 'formatText') {
-                formatCells(payload);
-                return true;
-              } else if (type === 'insertText') {
-                clearHighlight();
-                return false;
-              }
-
-              return false;
-            }, LowPriority);
-            editorListeners.add(deleteCharacterListener);
+        if (x !== (isForward ? tableSelection.grid.columns - 1 : 0)) {
+          selectTableCellNode(tableNode.getCellNodeFromCordsOrThrow(x + (isForward ? 1 : -1), y, tableSelection.grid));
+        } else {
+          if (y !== (isForward ? tableSelection.grid.rows - 1 : 0)) {
+            selectTableCellNode(tableNode.getCellNodeFromCordsOrThrow(isForward ? 0 : tableSelection.grid.columns - 1, y + (isForward ? 1 : -1), tableSelection.grid));
+          } else if (!isForward) {
+            tableNode.selectPrevious();
+          } else {
+            tableNode.selectNext();
           }
-        } else if (cellX === currentX && cellY === currentY) {
-          return;
-        }
-
-        currentX = cellX;
-        currentY = cellY;
-
-        if (isHighlightingCells) {
-          const fromX = Math.min(startX, currentX);
-          const toX = Math.max(startX, currentX);
-          const fromY = Math.min(startY, currentY);
-          const toY = Math.max(startY, currentY);
-          editor.update(() => {
-            highlightedCells = tableNode.setSelectionState({
-              fromX,
-              fromY,
-              toX,
-              toY
-            });
-          });
         }
-      }
-    }
-  });
-
-  const clearHighlight = () => {
-    editor.update(() => {
-      isHighlightingCells = false;
-      isSelected = false;
-      startX = -1;
-      startY = -1;
-      currentX = -1;
-      currentY = -1;
-      editor.update(() => {
-        tableNode.setSelectionState(null);
-      });
-      highlightedCells = [];
-
-      if (deleteCharacterListener !== null) {
-        deleteCharacterListener();
-        deleteCharacterListener = null;
-        editorListeners.delete(deleteCharacterListener);
-      }
-
-      const parent = removeHighlightStyle.parentNode;
-
-      if (parent != null) {
-        parent.removeChild(removeHighlightStyle);
-      }
-    });
-  };
-
-  tableElement.addEventListener('mouseleave', event => {
-    if (isSelected) {
-      return;
-    }
-  });
-
-  const formatCells = type => {
-    let selection = lexical.$getSelection();
-
-    if (!lexical.$isRangeSelection(selection)) {
-      selection = lexical.$createRangeSelection();
-    } // This is to make Flow play ball.
-
 
-    const formatSelection = selection;
-    const anchor = formatSelection.anchor;
-    const focus = formatSelection.focus;
-    highlightedCells.forEach(highlightedCell => {
-      const cellNode = lexical.$getNearestNodeFromDOMNode(highlightedCell.elem);
-
-      if (lexical.$isElementNode(cellNode) && cellNode.getTextContentSize() !== 0) {
-        anchor.set(cellNode.getKey(), 0, 'element');
-        focus.set(cellNode.getKey(), cellNode.getChildrenSize(), 'element');
-        formatSelection.formatText(type);
+        return true;
       }
-    }); // Collapse selection
 
-    selection.anchor.set(selection.anchor.key, selection.anchor.offset, selection.anchor.type);
-    selection.focus.set(selection.anchor.key, selection.anchor.offset, selection.anchor.type);
-    lexical.$setSelection(selection);
-  };
+    case 'up':
+      {
+        if (y !== 0) {
+          selectTableCellNode(tableNode.getCellNodeFromCordsOrThrow(x, y - 1, tableSelection.grid));
+        } else {
+          tableNode.selectPrevious();
+        }
 
-  tableElement.addEventListener('mousedown', event => {
-    if (isSelected) {
-      if (isHighlightingCells) {
-        clearHighlight();
+        return true;
       }
 
-      return;
-    }
-
-    setTimeout(() => {
-      if (isHighlightingCells) {
-        clearHighlight();
-      } // $FlowFixMe: event.target is always a Node on the DOM
-
-
-      const cell = getCellFromTarget(event.target);
+    case 'down':
+      {
+        if (y !== tableSelection.grid.rows - 1) {
+          selectTableCellNode(tableNode.getCellNodeFromCordsOrThrow(x, y + 1, tableSelection.grid));
+        } else {
+          tableNode.selectNext();
+        }
 
-      if (cell !== null) {
-        isSelected = true;
-        startX = cell.x;
-        startY = cell.y;
-        document.addEventListener('mouseup', () => {
-          isSelected = false;
-        }, {
-          capture: true,
-          once: true
-        });
+        return true;
       }
-    }, 0);
-  });
-  window.addEventListener('click', e => {
-    if (highlightedCells.length > 0 && !tableElement.contains(e.target) && rootElement.contains(e.target)) {
-      editor.update(() => {
-        tableNode.setSelectionState(null);
-      });
-    }
-  });
+  }
 
-  const selectGridNodeInDirection = (x, y, direction) => {
-    switch (direction) {
-      case 'backward':
-      case 'forward':
-        {
-          const isForward = direction === 'forward';
+  return false;
+};
 
-          if (x !== (isForward ? grid.columns - 1 : 0)) {
-            tableNode.getCellNodeFromCordsOrThrow(x + (isForward ? 1 : -1), y).select();
-          } else {
-            if (y !== (isForward ? grid.rows - 1 : 0)) {
-              tableNode.getCellNodeFromCordsOrThrow(isForward ? 0 : grid.columns - 1, y + (isForward ? 1 : -1)).select();
-            } else if (!isForward) {
-              tableNode.selectPrevious();
-            } else {
-              tableNode.selectNext();
-            }
-          }
+const adjustFocusNodeInDirection = (tableSelection, tableNode, x, y, direction) => {
+  switch (direction) {
+    case 'backward':
+    case 'forward':
+      {
+        const isForward = direction === 'forward';
 
-          return true;
+        if (x !== (isForward ? tableSelection.grid.columns - 1 : 0)) {
+          tableSelection.adjustFocusCellForSelection(tableNode.getCellFromCordsOrThrow(x + (isForward ? 1 : -1), y, tableSelection.grid));
         }
 
-      case 'up':
-        {
-          if (y !== 0) {
-            tableNode.getCellNodeFromCordsOrThrow(x, y - 1).select();
-          } else {
-            tableNode.selectPrevious();
-          }
+        return true;
+      }
 
+    case 'up':
+      {
+        if (y !== 0) {
+          tableSelection.adjustFocusCellForSelection(tableNode.getCellFromCordsOrThrow(x, y - 1, tableSelection.grid));
           return true;
+        } else {
+          return false;
         }
+      }
 
-      case 'down':
-        {
-          if (y !== grid.rows - 1) {
-            tableNode.getCellNodeFromCordsOrThrow(x, y + 1).select();
-          } else {
-            tableNode.selectNext();
-          }
-
+    case 'down':
+      {
+        if (y !== tableSelection.grid.rows - 1) {
+          tableSelection.adjustFocusCellForSelection(tableNode.getCellFromCordsOrThrow(x, y + 1, tableSelection.grid));
           return true;
+        } else {
+          return false;
         }
-    }
-
-    return false;
-  };
-
-  const genericCommandListener = editor.addListener('command', (type, payload) => {
-    const selection = lexical.$getSelection();
-
-    if (!lexical.$isRangeSelection(selection)) {
-      return false;
-    }
-
-    const tableCellNode = $findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
-
-    if (!$isTableCellNode(tableCellNode)) {
-      return false;
-    }
-
-    if (type === 'deleteCharacter') {
-      if (highlightedCells.length === 0 && selection.isCollapsed() && selection.anchor.offset === 0 && selection.anchor.getNode().getPreviousSiblings().length === 0) {
-        return true;
-      }
-    }
-
-    if (type === 'keyTab') {
-      const event = payload;
-
-      if (selection.isCollapsed() && highlightedCells.length === 0) {
-        const currentCords = tableNode.getCordsFromCellNode(tableCellNode);
-        event.preventDefault();
-        selectGridNodeInDirection(currentCords.x, currentCords.y, !event.shiftKey && type === 'keyTab' ? 'forward' : 'backward');
-        return true;
       }
-    }
-
-    if (type === 'keyArrowDown' || type === 'keyArrowUp') {
-      const event = payload;
+  }
 
-      if (selection.isCollapsed() && highlightedCells.length === 0) {
-        const currentCords = tableNode.getCordsFromCellNode(tableCellNode);
-        const elementParentNode = $findMatchingParent(selection.anchor.getNode(), n => lexical.$isElementNode(n));
+  return false;
+};
 
-        if (type === 'keyArrowUp' && elementParentNode === tableCellNode.getFirstChild() || type === 'keyArrowDown' && elementParentNode === tableCellNode.getLastChild()) {
-          event.preventDefault();
-          event.stopImmediatePropagation();
-          selectGridNodeInDirection(currentCords.x, currentCords.y, type === 'keyArrowUp' ? 'up' : 'down');
-          return true;
-        }
-      }
-    }
+function selectTableCellNode(tableCell) {
+  const possibleParagraph = tableCell.getChildren().find(n => lexical.$isParagraphNode(n));
 
-    return false;
-  }, CriticalPriority);
-  editorListeners.add(genericCommandListener);
-  return () => Array.from(editorListeners).forEach(removeListener => removeListener ? removeListener() : null);
+  if (lexical.$isParagraphNode(possibleParagraph)) {
+    possibleParagraph.selectEnd();
+  } else {
+    tableCell.selectEnd();
+  }
 }
 
 /**
@@ -632,21 +1058,26 @@ class TableNode extends lexical.GridNode {
     return 'table';
   }
 
-  static clone(node, selectionShape, grid) {
-    // TODO: selectionShape and grid aren't being deeply cloned?
-    // They shouldn't really be on the table node IMO.
-    return new TableNode(node.__selectionShape, node.__grid, node.__key);
+  static clone(node) {
+    return new TableNode(node.__key);
+  }
+
+  static convertDOM() {
+    return {
+      table: node => ({
+        conversion: convertTableElement,
+        priority: 0
+      })
+    };
   }
 
-  constructor(selectionShape, grid, key) {
+  constructor(key) {
     super(key);
-    this.__selectionShape = selectionShape;
-    this.__grid = grid;
   }
 
   createDOM(config, editor) {
     const element = document.createElement('table');
-    addClassNamesToElement(element, config.theme.table);
+    utils.addClassNamesToElement(element, config.theme.table);
     return element;
   }
 
@@ -662,26 +1093,7 @@ class TableNode extends lexical.GridNode {
     return false;
   }
 
-  setSelectionState(selectionShape) {
-    const self = this.getWritable();
-    self.__selectionShape = selectionShape;
-    const grid = this.getGrid();
-    if (grid == null) return [];
-
-    if (!selectionShape) {
-      return updateCells(-1, -1, -1, -1, grid.cells);
-    }
-
-    return updateCells(selectionShape.fromX, selectionShape.toX, selectionShape.fromY, selectionShape.toY, grid.cells);
-  }
-
-  getSelectionState() {
-    return this.getLatest().__selectionShape;
-  }
-
-  getCordsFromCellNode(tableCellNode) {
-    const grid = this.getGrid();
-
+  getCordsFromCellNode(tableCellNode, grid) {
     if (!grid) {
       throw Error(`Grid not found.`);
     }
@@ -716,9 +1128,7 @@ class TableNode extends lexical.GridNode {
     throw new Error('Cell not found in table.');
   }
 
-  getCellNodeFromCords(x, y) {
-    const grid = this.getGrid();
-
+  getCellFromCords(x, y, grid) {
     if (!grid) {
       throw Error(`Grid not found.`);
     }
@@ -738,6 +1148,26 @@ class TableNode extends lexical.GridNode {
       return null;
     }
 
+    return cell;
+  }
+
+  getCellFromCordsOrThrow(x, y, grid) {
+    const cell = this.getCellFromCords(x, y, grid);
+
+    if (!cell) {
+      throw new Error('Cell not found at cords.');
+    }
+
+    return cell;
+  }
+
+  getCellNodeFromCords(x, y, grid) {
+    const cell = this.getCellFromCords(x, y, grid);
+
+    if (cell == null) {
+      return null;
+    }
+
     const node = lexical.$getNearestNodeFromDOMNode(cell.elem);
 
     if ($isTableCellNode(node)) {
@@ -747,8 +1177,8 @@ class TableNode extends lexical.GridNode {
     return null;
   }
 
-  getCellNodeFromCordsOrThrow(x, y) {
-    const node = this.getCellNodeFromCords(x, y);
+  getCellNodeFromCordsOrThrow(x, y, grid) {
+    const node = this.getCellNodeFromCords(x, y, grid);
 
     if (!node) {
       throw new Error('Node at cords not TableCellNode.');
@@ -757,20 +1187,24 @@ class TableNode extends lexical.GridNode {
     return node;
   }
 
-  setGrid(grid) {
-    const self = this.getWritable();
-    self.__grid = grid;
-    return self;
+  canSelectBefore() {
+    return true;
   }
 
-  getGrid() {
-    return this.getLatest().__grid;
-  }
+}
+function $getElementGridForTableNode(editor, tableNode) {
+  const tableElement = editor.getElementByKey(tableNode.getKey());
 
-  canSelectBefore() {
-    return true;
+  if (tableElement == null) {
+    throw new Error('Table Element Not Found');
   }
 
+  return getTableGrid(tableElement);
+}
+function convertTableElement(domNode) {
+  return {
+    node: $createTableNode()
+  };
 }
 function $createTableNode() {
   return new TableNode();
@@ -793,21 +1227,46 @@ class TableRowNode extends lexical.GridRowNode {
   }
 
   static clone(node) {
-    return new TableRowNode(node.__key);
+    return new TableRowNode(node.__height, node.__key);
   }
 
-  constructor(key) {
+  static convertDOM() {
+    return {
+      tr: node => ({
+        conversion: convertTableRowElement,
+        priority: 0
+      })
+    };
+  }
+
+  constructor(height, key) {
     super(key);
+    this.__height = height;
   }
 
   createDOM(config) {
     const element = document.createElement('tr');
-    addClassNamesToElement(element, config.theme.tableRow);
+
+    if (this.__height) {
+      element.style.height = `${this.__height}px`;
+    }
+
+    utils.addClassNamesToElement(element, config.theme.tableRow);
     return element;
   }
 
-  updateDOM() {
-    return false;
+  setHeight(height) {
+    const self = this.getWritable();
+    self.__height = height;
+    return this.__height;
+  }
+
+  getHeight() {
+    return this.getLatest().__height;
+  }
+
+  updateDOM(prevNode) {
+    return prevNode.__height !== this.__height;
   }
 
   canBeEmpty() {
@@ -815,8 +1274,13 @@ class TableRowNode extends lexical.GridRowNode {
   }
 
 }
-function $createTableRowNode() {
-  return new TableRowNode();
+function convertTableRowElement(domNode) {
+  return {
+    node: $createTableRowNode()
+  };
+}
+function $createTableRowNode(height) {
+  return new TableRowNode(height);
 }
 function $isTableRowNode(node) {
   return node instanceof TableRowNode;
@@ -837,14 +1301,14 @@ function $createTableNodeWithDimensions(rowCount, columnCount, includeHeaders =
     const tableRowNode = $createTableRowNode();
 
     for (let iColumn = 0; iColumn < columnCount; iColumn++) {
-      const headerStyles = new Set();
+      let headerState = TableCellHeaderStates.NO_STATUS;
 
       if (includeHeaders) {
-        if (iRow === 0) headerStyles.add('row');
-        if (iColumn === 0) headerStyles.add('column');
+        if (iRow === 0) headerState |= TableCellHeaderStates.ROW;
+        if (iColumn === 0) headerState |= TableCellHeaderStates.COLUMN;
       }
 
-      const tableCellNode = $createTableCellNode(headerStyles);
+      const tableCellNode = $createTableCellNode(headerState);
       const paragraphNode = lexical.$createParagraphNode();
       paragraphNode.append(lexical.$createTextNode());
       tableCellNode.append(paragraphNode);
@@ -857,7 +1321,7 @@ function $createTableNodeWithDimensions(rowCount, columnCount, includeHeaders =
   return tableNode;
 }
 function $getTableCellNodeFromLexicalNode(startingNode) {
-  const node = $findMatchingParent(startingNode, n => $isTableCellNode(n));
+  const node = utils.$findMatchingParent(startingNode, n => $isTableCellNode(n));
 
   if ($isTableCellNode(node)) {
     return node;
@@ -866,7 +1330,7 @@ function $getTableCellNodeFromLexicalNode(startingNode) {
   return null;
 }
 function $getTableRowNodeFromTableCellNodeOrThrow(startingNode) {
-  const node = $findMatchingParent(startingNode, n => $isTableRowNode(n));
+  const node = utils.$findMatchingParent(startingNode, n => $isTableRowNode(n));
 
   if ($isTableRowNode(node)) {
     return node;
@@ -875,7 +1339,7 @@ function $getTableRowNodeFromTableCellNodeOrThrow(startingNode) {
   throw new Error('Expected table cell to be inside of table row.');
 }
 function $getTableNodeFromLexicalNodeOrThrow(startingNode) {
-  const node = $findMatchingParent(startingNode, n => $isTableNode(n));
+  const node = utils.$findMatchingParent(startingNode, n => $isTableNode(n));
 
   if ($isTableNode(node)) {
     return node;
@@ -892,17 +1356,17 @@ function $getTableColumnIndexFromTableCellNode(tableCellNode) {
   const tableRowNode = $getTableRowNodeFromTableCellNodeOrThrow(tableCellNode);
   return tableRowNode.getChildren().findIndex(n => n.is(tableCellNode));
 }
-function $getTableCellSiblingsFromTableCellNode(tableCellNode) {
+function $getTableCellSiblingsFromTableCellNode(tableCellNode, grid) {
   const tableNode = $getTableNodeFromLexicalNodeOrThrow(tableCellNode);
   const {
     x,
     y
-  } = tableNode.getCordsFromCellNode(tableCellNode);
+  } = tableNode.getCordsFromCellNode(tableCellNode, grid);
   return {
-    above: tableNode.getCellNodeFromCords(x, y - 1),
-    below: tableNode.getCellNodeFromCords(x, y + 1),
-    left: tableNode.getCellNodeFromCords(x - 1, y),
-    right: tableNode.getCellNodeFromCords(x + 1, y)
+    above: tableNode.getCellNodeFromCords(x, y - 1, grid),
+    below: tableNode.getCellNodeFromCords(x, y + 1, grid),
+    left: tableNode.getCellNodeFromCords(x - 1, y, grid),
+    right: tableNode.getCellNodeFromCords(x + 1, y, grid)
   };
 }
 function $removeTableRowAtIndex(tableNode, indexToDelete) {
@@ -916,7 +1380,7 @@ function $removeTableRowAtIndex(tableNode, indexToDelete) {
   targetRowNode.remove();
   return tableNode;
 }
-function $insertTableRow(tableNode, targetIndex, shouldInsertAfter = true, rowCount) {
+function $insertTableRow(tableNode, targetIndex, shouldInsertAfter = true, rowCount, grid) {
   const tableRows = tableNode.getChildren();
 
   if (targetIndex >= tableRows.length || targetIndex < 0) {
@@ -941,14 +1405,15 @@ function $insertTableRow(tableNode, targetIndex, shouldInsertAfter = true, rowCo
         const {
           above,
           below
-        } = $getTableCellSiblingsFromTableCellNode(tableCellFromTargetRow);
-        const headerStyles = new Set();
+        } = $getTableCellSiblingsFromTableCellNode(tableCellFromTargetRow, grid);
+        let headerState = TableCellHeaderStates.NO_STATUS;
+        const width = above && above.getWidth() || below && below.getWidth() || null;
 
-        if (above && above.getHeaderStyles().has('column') || below && below.getHeaderStyles().has('column')) {
-          headerStyles.add('column');
+        if (above && above.hasHeaderState(TableCellHeaderStates.COLUMN) || below && below.hasHeaderState(TableCellHeaderStates.COLUMN)) {
+          headerState |= TableCellHeaderStates.COLUMN;
         }
 
-        const tableCellNode = $createTableCellNode(headerStyles);
+        const tableCellNode = $createTableCellNode(headerState, 1, width);
         tableCellNode.append(lexical.$createParagraphNode());
         newTableRowNode.append(tableCellNode);
       }
@@ -973,13 +1438,13 @@ function $insertTableColumn(tableNode, targetIndex, shouldInsertAfter = true, co
 
     if ($isTableRowNode(currentTableRowNode)) {
       for (let c = 0; c < columnCount; c++) {
-        const headerStyles = new Set();
+        let headerState = TableCellHeaderStates.NO_STATUS;
 
         if (r === 0) {
-          headerStyles.add('row');
+          headerState |= TableCellHeaderStates.ROW;
         }
 
-        const newTableCell = $createTableCellNode(headerStyles);
+        const newTableCell = $createTableCellNode(headerState);
         newTableCell.append(lexical.$createParagraphNode());
         const tableRowChildren = currentTableRowNode.getChildren();
 
@@ -1020,12 +1485,22 @@ function $deleteTableColumn(tableNode, targetIndex) {
   return tableNode;
 }
 
-exports.$applyCustomTableHandlers = $applyCustomTableHandlers;
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+const INSERT_TABLE_COMMAND = lexical.createCommand();
+
 exports.$createTableCellNode = $createTableCellNode;
 exports.$createTableNode = $createTableNode;
 exports.$createTableNodeWithDimensions = $createTableNodeWithDimensions;
 exports.$createTableRowNode = $createTableRowNode;
 exports.$deleteTableColumn = $deleteTableColumn;
+exports.$getElementGridForTableNode = $getElementGridForTableNode;
 exports.$getTableCellNodeFromLexicalNode = $getTableCellNodeFromLexicalNode;
 exports.$getTableColumnIndexFromTableCellNode = $getTableColumnIndexFromTableCellNode;
 exports.$getTableNodeFromLexicalNodeOrThrow = $getTableNodeFromLexicalNodeOrThrow;
@@ -1037,6 +1512,12 @@ exports.$isTableCellNode = $isTableCellNode;
 exports.$isTableNode = $isTableNode;
 exports.$isTableRowNode = $isTableRowNode;
 exports.$removeTableRowAtIndex = $removeTableRowAtIndex;
+exports.INSERT_TABLE_COMMAND = INSERT_TABLE_COMMAND;
+exports.TableCellHeaderStates = TableCellHeaderStates;
 exports.TableCellNode = TableCellNode;
 exports.TableNode = TableNode;
 exports.TableRowNode = TableRowNode;
+exports.TableSelection = TableSelection;
+exports.applyTableHandlers = applyTableHandlers;
+exports.getCellFromTarget = getCellFromTarget;
+exports.getTableSelectionFromTableElement = getTableSelectionFromTableElement;