@contentful/field-editor-rich-text 2.0.0-next.1 → 2.0.0-next.2

package/dist/field-editor-rich-text.esm.js

@@ -1,7 +1,7 @@
 import React__default, { createElement, useMemo, useState, useEffect, Fragment, useCallback } from 'react';
 import noop from 'lodash-es/noop';
-import { toContentfulDocument, toSlatejsDocument } from '@contentful/contentful-slatejs-adapter';
-import { TOP_LEVEL_BLOCKS, BLOCKS, CONTAINERS, VOID_BLOCKS, INLINES, TABLE_BLOCKS, LIST_ITEM_BLOCKS, MARKS, EMPTY_DOCUMENT } from '@contentful/rich-text-types';
+import { toSlatejsDocument, toContentfulDocument } from '@contentful/contentful-slatejs-adapter';
+import { TOP_LEVEL_BLOCKS, BLOCKS, CONTAINERS, VOID_BLOCKS, INLINES, TABLE_BLOCKS, TEXT_CONTAINERS, LIST_ITEM_BLOCKS, MARKS, EMPTY_DOCUMENT } from '@contentful/rich-text-types';
 import { getScheduleTooltipContent, useEntities, ScheduledIconWithTooltip, MissingEntityCard, AssetThumbnail, EntityProvider } from '@contentful/field-editor-reference';
 import { css, cx } from 'emotion';
 import tokens from '@contentful/f36-tokens';
@@ -9,24 +9,15 @@ import deepEquals from 'fast-deep-equal';
 import { Button, Tooltip, Menu, EntryCard, MenuItem, AssetCard, Text as Text$1, ModalContent, Form, FormControl, TextInput, Select, FormLabel, TextLink, ModalControls, IconButton, Flex, Icon, InlineEntryCard } from '@contentful/f36-components';
 import { useSelected, useFocused, ReactEditor, useReadOnly } from 'slate-react';
 import { HorizontalRuleIcon, ChevronDownIcon, QuoteIcon, ListBulletedIcon, ListNumberedIcon, FormatBoldIcon, CodeIcon, FormatItalicIcon, FormatUnderlinedIcon, ClockIcon, LinkIcon, TableIcon, PlusIcon, AssetIcon, EmbeddedEntryBlockIcon, EmbeddedEntryInlineIcon } from '@contentful/f36-icons';
-import { Editor, Transforms, Element, Text, Node as Node$1, Path, Range } from 'slate';
-import { getPlatePluginOptions, usePlateEditorRef, getRenderElement, getPlatePluginTypes, getRenderLeaf, getPlatePluginType, Plate, createReactPlugin, createHistoryPlugin } from '@udecode/plate-core';
-import { getText, getElementDeserializer, getLeafDeserializer, setNodes, insertNodes, toggleNodeType, findNode, getToggleMarkOnKeyDown, isMarkActive, toggleMark, getAbove, getChildren, someNode, getToggleElementOnKeyDown, getNodes } from '@udecode/plate-common';
+import { Editor, Element, Transforms, Text, Node as Node$1, Path, Range } from 'slate';
+import { getText, getElementDeserializer, getPlatePluginOptions, getLeafDeserializer, usePlateEditorRef, getRenderElement, getPlatePluginTypes, setNodes, insertNodes, toggleNodeType, findNode, ELEMENT_LI, ELEMENT_UL, ELEMENT_OL, ELEMENT_LIC, toggleList, createListPlugin as createListPlugin$1, getParent, getAbove, withList, getRenderLeaf, getToggleMarkOnKeyDown, isMarkActive, toggleMark, ELEMENT_TABLE, ELEMENT_TH, ELEMENT_TR, ELEMENT_TD, getChildren, insertTable, isFirstChild as isFirstChild$1, isAncestorEmpty, someNode, getPlatePluginType, getEmptyRowNode, getEmptyCellNode, deleteRow, deleteColumn, deleteTable, createTablePlugin as createTablePlugin$1, getTableOnKeyDown, ELEMENT_PARAGRAPH, getToggleElementOnKeyDown, createExitBreakPlugin, createTrailingBlockPlugin, getNodes, createDeserializeHTMLPlugin, createDeserializeAstPlugin, createReactPlugin, createHistoryPlugin, Plate } from '@udecode/plate';
 import constate from 'constate';
 import find from 'lodash-es/find';
 import flow from 'lodash-es/flow';
 import get from 'lodash-es/get';
-import { ELEMENT_LI, ELEMENT_UL, ELEMENT_OL, ELEMENT_LIC, toggleList, createListPlugin as createListPlugin$1, withList } from '@udecode/plate-list';
-import { documentToPlainTextString } from '@contentful/rich-text-plain-text-renderer';
 import { entityHelpers, isValidImage, shortenStorageUnit, ModalDialogLauncher, FieldConnector } from '@contentful/field-editor-shared';
 import mimetype from '@contentful/mimetype';
-import { ELEMENT_TABLE, ELEMENT_TH, ELEMENT_TR, ELEMENT_TD, insertTable, getEmptyRowNode, getEmptyCellNode, deleteRow, deleteColumn, deleteTable, createTablePlugin as createTablePlugin$1, getTableOnKeyDown } from '@udecode/plate-table';
-import { createDeserializeAstPlugin } from '@udecode/plate-ast-serializer';
-import { createDeserializeHTMLPlugin } from '@udecode/plate-html-serializer';
-import { ELEMENT_PARAGRAPH } from '@udecode/plate-paragraph';
-import { createExitBreakPlugin } from '@udecode/plate-break';
 import values from 'lodash-es/values';
-import { createTrailingBlockPlugin } from '@udecode/plate-trailing-block';
 import PropTypes from 'prop-types';
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
@@ -610,6 +601,33 @@ function currentSelectionPrecedesTableCell(editor) {
   var nextNode = getNextNode(editor);
   return !!nextNode && TABLE_BLOCKS.includes(nextNode.type) && isAtEndOfTextSelection(editor);
 }
+var replaceNode = function replaceNode(editor, path, replacement) {
+  Transforms.removeNodes(editor, {
+    at: path
+  });
+  Transforms.insertNodes(editor, replacement, {
+    at: path
+  });
+};
+/**
+ * It filters out all paragraphs and headings from a path and convert them into paragraphs.
+ */
+
+function extractParagraphsAt(editor, path) {
+  var paragraphs = Array.from(Editor.nodes(editor, {
+    at: path,
+    match: function match(node) {
+      return TEXT_CONTAINERS.includes(node.type);
+    },
+    mode: 'all'
+  })).map(function (_ref2) {
+    var node = _ref2[0];
+    return _extends({}, node, {
+      type: BLOCKS.PARAGRAPH
+    });
+  });
+  return paragraphs;
+}
 
 function deserializeLeaf(type, rules) {
   return function (editor) {
@@ -972,8 +990,8 @@ var H1 = /*#__PURE__*/createHeading('h1', BLOCKS.HEADING_1);
 var H2 = /*#__PURE__*/createHeading('h2', BLOCKS.HEADING_2);
 var H3 = /*#__PURE__*/createHeading('h3', BLOCKS.HEADING_3);
 var H4 = /*#__PURE__*/createHeading('h4', BLOCKS.HEADING_4);
-var H5 = /*#__PURE__*/createHeading('h1', BLOCKS.HEADING_5);
-var H6 = /*#__PURE__*/createHeading('h1', BLOCKS.HEADING_6);
+var H5 = /*#__PURE__*/createHeading('h5', BLOCKS.HEADING_5);
+var H6 = /*#__PURE__*/createHeading('h6', BLOCKS.HEADING_6);
 function createHeadingPlugin() {
   var headings = [BLOCKS.HEADING_1, BLOCKS.HEADING_2, BLOCKS.HEADING_3, BLOCKS.HEADING_4, BLOCKS.HEADING_5, BLOCKS.HEADING_6];
   return {
@@ -1141,15 +1159,6 @@ var withQuoteOptions = (_withQuoteOptions = {}, _withQuoteOptions[BLOCKS.QUOTE]
  * A copy of Plate's list plugin with a few adjustments
  * to fix pasting text inside lists.
  */
-
-var slateNodesToText = function slateNodesToText(nodes) {
-  var contentfulNode = toContentfulDocument({
-    document: nodes,
-    schema: schema
-  });
-  return documentToPlainTextString(contentfulNode);
-};
-
 var getListInsertFragment = function getListInsertFragment(editor) {
   var insertFragment = editor.insertFragment;
   var li = getPlatePluginOptions(editor, ELEMENT_LI);
@@ -1205,10 +1214,7 @@ var getListInsertFragment = function getListInsertFragment(editor) {
       var nodes = fragment.flatMap(function (node) {
         return trimList(node);
       });
-      var text = slateNodesToText(nodes);
-      return Transforms.insertNodes(editor, [{
-        text: text
-      }], {
+      return Transforms.insertNodes(editor, nodes, {
         at: editor.selection || Path.next(liPath),
         select: true
       });
@@ -1281,6 +1287,88 @@ var withListOptions = (_withListOptions = {}, _withListOptions[ELEMENT_LIC] = {
   component: OL
 }, _withListOptions);
 
+var emptyNodeOfType = function emptyNodeOfType(type) {
+  return {
+    type: type,
+    children: [],
+    data: {}
+  };
+};
+
+var isList = function isList(node) {
+  return [BLOCKS.OL_LIST, BLOCKS.UL_LIST].includes(node.type);
+};
+
+var isListItem = function isListItem(node) {
+  return node.type === BLOCKS.LIST_ITEM;
+};
+
+var hasListAsDirectParent = function hasListAsDirectParent(editor, path) {
+  var _ref = getParent(editor, path) || [],
+      parentNode = _ref[0];
+
+  return isList(parentNode);
+};
+
+var isValidInsideListItem = function isValidInsideListItem(node) {
+  return Text.isText(node) || LIST_ITEM_BLOCKS.concat(Object.values(INLINES)).includes(node.type);
+};
+
+var replaceInvalidListItemWithText = function replaceInvalidListItemWithText(editor, path) {
+  var textFromEntry = extractParagraphsAt(editor, path);
+  replaceNode(editor, path, textFromEntry);
+};
+/**
+ * Ensures each list item follows the list schema.
+ * Returns true if the list needed to have been normalized.
+ */
+
+
+var normalizeList = function normalizeList(editor, path) {
+  for (var _iterator = _createForOfIteratorHelperLoose(Node$1.children(editor, path)), _step; !(_step = _iterator()).done;) {
+    var _step$value = _step.value,
+        child = _step$value[0],
+        childPath = _step$value[1];
+
+    if (Element.isElement(child) && !isListItem(child)) {
+      Transforms.wrapNodes(editor, emptyNodeOfType(BLOCKS.LIST_ITEM), {
+        at: childPath
+      });
+      return true;
+    }
+  }
+
+  return false;
+};
+
+var getNearestListAncestor = function getNearestListAncestor(editor, path) {
+  return getAbove(editor, {
+    at: path,
+    mode: 'lowest',
+    match: isList
+  }) || [];
+};
+/**
+ * Places orphaned list items in a list. If there's a list somewhere
+ * in the node's ancestors, defaults to that list type, else places
+ * the list item in an unordered list.
+ */
+
+
+var normalizeOrphanedListItem = function normalizeOrphanedListItem(editor, path) {
+  var _getNearestListAncest = getNearestListAncestor(editor, path),
+      parentList = _getNearestListAncest[0];
+
+  var parentListType = parentList == null ? void 0 : parentList.type;
+  Transforms.wrapNodes(editor, {
+    type: parentListType || BLOCKS.UL_LIST,
+    children: [],
+    data: {}
+  }, {
+    at: path
+  });
+};
+
 var withCustomList = function withCustomList(options) {
   var withDefaultOverrides = withList(options);
   return function (editor) {
@@ -1290,6 +1378,52 @@ var withCustomList = function withCustomList(options) {
     editor.insertFragment = insertFragment; // Use our custom getListInsertFragment
 
     editor.insertFragment = getListInsertFragment(editor);
+    var normalizeNode = editor.normalizeNode;
+
+    editor.normalizeNode = function (entry) {
+      var node = entry[0],
+          path = entry[1];
+
+      if (isList(node)) {
+        if (normalizeList(editor, path)) {
+          return;
+        }
+      } else if (isListItem(node)) {
+        if (!hasListAsDirectParent(editor, path)) {
+          normalizeOrphanedListItem(editor, path);
+          return;
+        }
+
+        var listItemChildren = Array.from(Node$1.children(editor, path)); // Handle list items with no paragraph/text
+
+        if (listItemChildren.length === 0) {
+          Transforms.insertNodes(editor, [{
+            type: BLOCKS.PARAGRAPH,
+            data: {},
+            children: [{
+              text: ''
+            }]
+          }], {
+            at: path.concat([0])
+          });
+          return;
+        }
+
+        for (var _i = 0, _listItemChildren = listItemChildren; _i < _listItemChildren.length; _i++) {
+          var _listItemChildren$_i = _listItemChildren[_i],
+              child = _listItemChildren$_i[0],
+              childPath = _listItemChildren$_i[1];
+
+          if (Element.isElement(child) && !isValidInsideListItem(child)) {
+            replaceInvalidListItemWithText(editor, childPath);
+            return;
+          }
+        }
+      }
+
+      normalizeNode(entry);
+    };
+
     return editor;
   };
 };
@@ -2890,7 +3024,7 @@ function HyperlinkModal(props) {
 
   return /*#__PURE__*/createElement(EntityProvider, {
     sdk: props.sdk
-  }, /*#__PURE__*/createElement(Fragment, null, /*#__PURE__*/createElement(ModalContent, null, /*#__PURE__*/createElement(Form, null, /*#__PURE__*/createElement(FormControl, {
+  }, /*#__PURE__*/createElement(Fragment, null, /*#__PURE__*/createElement(ModalContent, null, /*#__PURE__*/createElement(Form, null, !props.linkType && /*#__PURE__*/createElement(FormControl, {
     id: "link-text",
     isRequired: true
   }, /*#__PURE__*/createElement(FormControl.Label, null, "Link text"), /*#__PURE__*/createElement(TextInput, {
@@ -3386,6 +3520,7 @@ function insertTableAndFocusFirstCell(editor) {
     header: true
   });
   moveToFirstCellFromSelectedTable(editor);
+  replaceEmptyParagraphWithTable(editor);
 }
 function isTableActive(editor) {
   var tableElements = [ELEMENT_TABLE, ELEMENT_TH, ELEMENT_TR, ELEMENT_TD];
@@ -3415,6 +3550,36 @@ function isTableHeaderEnabled(editor) {
     return node.type === BLOCKS.TABLE_HEADER_CELL;
   });
 }
+function replaceEmptyParagraphWithTable(editor) {
+  var tablePath = getAncestorPathFromSelection(editor);
+  if (!tablePath || isFirstChild$1(tablePath)) return;
+  var previousPath = Path.previous(tablePath);
+  if (!previousPath) return;
+
+  var _Editor$nodes = Editor.nodes(editor, {
+    at: previousPath,
+    match: function match(node) {
+      return node.type === BLOCKS.PARAGRAPH;
+    }
+  }),
+      nodes = _Editor$nodes[0];
+
+  if (!nodes) return;
+  var previousNode = nodes[0];
+  var isPreviousNodeTextEmpty = isAncestorEmpty(editor, previousNode);
+
+  if (isPreviousNodeTextEmpty) {
+    // Switch table with previous empty paragraph
+    Transforms.moveNodes(editor, {
+      at: tablePath,
+      to: previousPath
+    }); // Remove previous paragraph that now is under the table
+
+    Transforms.removeNodes(editor, {
+      at: tablePath
+    });
+  }
+}
 
 function useTracking(_ref) {
   var onAction = _ref.onAction;
@@ -3670,17 +3835,117 @@ var TableActions = function TableActions() {
   }, "Delete table")));
 };
 
-var _templateObject$4, _templateObject2$3, _templateObject3$3, _templateObject4$1, _styles$1, _withTableOptions;
-var styles$f = (_styles$1 = {}, _styles$1[BLOCKS.TABLE] = /*#__PURE__*/css(_templateObject$4 || (_templateObject$4 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n    margin-bottom: 1.5em;\n    border-collapse: collapse;\n    border-radius: 5px;\n    border-style: hidden;\n    box-shadow: 0 0 0 1px ", ";\n    width: 100%;\n    table-layout: fixed;\n    overflow: hidden;\n  "])), tokens.gray400), _styles$1[BLOCKS.TABLE_ROW] = /*#__PURE__*/css(_templateObject2$3 || (_templateObject2$3 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n    border: 1px solid ", ";\n    &:hover td {\n      background-color: transparent !important;\n    }\n  "])), tokens.gray400), _styles$1[BLOCKS.TABLE_HEADER_CELL] = /*#__PURE__*/css(_templateObject3$3 || (_templateObject3$3 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n    background-color: ", ";\n    border: 1px solid ", ";\n    padding: 10px 12px;\n    font-weight: ", ";\n    text-align: left;\n    min-width: 48px;\n    position: relative;\n    div:last-child {\n      margin-bottom: 0;\n    }\n  "])), tokens.gray200, tokens.gray400, tokens.fontWeightMedium), _styles$1[BLOCKS.TABLE_CELL] = /*#__PURE__*/css(_templateObject4$1 || (_templateObject4$1 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n    border: 1px solid ", ";\n    padding: 10px 12px;\n    min-width: 48px;\n    position: relative;\n    div:last-child {\n      margin-bottom: 0;\n    }\n  "])), tokens.gray400), _styles$1);
+/**
+ * Injects a custom element normalization handler.
+ *
+ * Handlers must explicity return "true" to indicate a pass.
+ * A pass is when a handler didn't encounter any normalization
+ * paths (i.e. all nodes were valid)
+ *
+ * Important read:
+ * https://docs.slatejs.org/concepts/11-normalizing#multi-pass-normalizing
+ */
 
-var slateNodeToText = function slateNodeToText(node) {
-  var contentfulNode = toContentfulDocument({
-    document: [node],
-    schema: schema
-  });
-  return documentToPlainTextString(contentfulNode);
+var withNormalizer = function withNormalizer(editor, handler) {
+  var normalizeNode = editor.normalizeNode;
+
+  editor.normalizeNode = function (entry) {
+    var node = entry[0];
+    var passed = false;
+
+    if (Element.isElement(node)) {
+      passed = handler(editor, entry) === true;
+    }
+
+    if (passed) {
+      normalizeNode(entry);
+    }
+  };
 };
 
+var isTable = function isTable(node) {
+  return node.type === BLOCKS.TABLE;
+};
+
+var isTableCell = function isTableCell(node) {
+  return node.type === BLOCKS.TABLE_CELL || node.type === BLOCKS.TABLE_HEADER_CELL;
+};
+/**
+ * Normalizes TABLE_CELL & TABLE_HEADER_CELL nodes
+ */
+
+
+var normalizeTableCell = function normalizeTableCell(editor, entry) {
+  var node = entry[0],
+      path = entry[1];
+
+  if (!isTableCell(node)) {
+    return true;
+  }
+
+  for (var _iterator = _createForOfIteratorHelperLoose(Node$1.children(editor, path)), _step; !(_step = _iterator()).done;) {
+    var _step$value = _step.value,
+        child = _step$value[0],
+        childPath = _step$value[1];
+
+    if (!Element.isElement(child)) {
+      continue;
+    }
+
+    var isValidTableCellItem = CONTAINERS[node.type].includes(child.type);
+
+    if (!isValidTableCellItem) {
+      var text = extractParagraphsAt(editor, childPath);
+      replaceNode(editor, childPath, text);
+      return;
+    }
+  }
+
+  return true;
+};
+/**
+ * Normalizes TABLE nodes
+ */
+
+
+var normalizeTable = function normalizeTable(editor, entry) {
+  var node = entry[0],
+      path = entry[1];
+
+  if (!isTable(node)) {
+    return true;
+  } // All direct children must be of type TABLE_ROW
+
+
+  for (var _iterator2 = _createForOfIteratorHelperLoose(Node$1.children(editor, path)), _step2; !(_step2 = _iterator2()).done;) {
+    var _step2$value = _step2.value,
+        child = _step2$value[0],
+        childPath = _step2$value[1];
+
+    if (!Element.isElement(child)) {
+      continue;
+    }
+
+    var isValidTableChild = CONTAINERS[BLOCKS.TABLE].includes(child.type);
+
+    if (!isValidTableChild) {
+      Transforms.removeNodes(editor, {
+        at: childPath
+      });
+      return;
+    }
+  }
+
+  return true;
+};
+
+var addTableNormalizers = function addTableNormalizers(editor) {
+  withNormalizer(editor, normalizeTable);
+  withNormalizer(editor, normalizeTableCell);
+};
+
+var _templateObject$4, _templateObject2$3, _templateObject3$3, _templateObject4$1, _styles$1, _withTableOptions;
+var styles$f = (_styles$1 = {}, _styles$1[BLOCKS.TABLE] = /*#__PURE__*/css(_templateObject$4 || (_templateObject$4 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n    margin-bottom: 1.5em;\n    border-collapse: collapse;\n    border-radius: 5px;\n    border-style: hidden;\n    box-shadow: 0 0 0 1px ", ";\n    width: 100%;\n    table-layout: fixed;\n    overflow: hidden;\n  "])), tokens.gray400), _styles$1[BLOCKS.TABLE_ROW] = /*#__PURE__*/css(_templateObject2$3 || (_templateObject2$3 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n    border: 1px solid ", ";\n\n    &:hover td {\n      background-color: transparent !important;\n    }\n  "])), tokens.gray400), _styles$1[BLOCKS.TABLE_HEADER_CELL] = /*#__PURE__*/css(_templateObject3$3 || (_templateObject3$3 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n    background-color: ", ";\n    border: 1px solid ", ";\n    padding: 10px 12px;\n    font-weight: ", ";\n    text-align: left;\n    min-width: 48px;\n    position: relative;\n\n    div:last-child {\n      margin-bottom: 0;\n    }\n  "])), tokens.gray200, tokens.gray400, tokens.fontWeightMedium), _styles$1[BLOCKS.TABLE_CELL] = /*#__PURE__*/css(_templateObject4$1 || (_templateObject4$1 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n    border: 1px solid ", ";\n    padding: 10px 12px;\n    min-width: 48px;\n    position: relative;\n\n    div:last-child {\n      margin-bottom: 0;\n    }\n  "])), tokens.gray400), _styles$1);
 var Table = function Table(props) {
   return /*#__PURE__*/createElement("table", Object.assign({}, props.attributes, {
     className: styles$f[BLOCKS.TABLE]
@@ -3744,56 +4009,6 @@ function addTableTrackingEvents(editor, _ref) {
   };
 }
 
-var paragraph = function paragraph() {
-  return {
-    type: BLOCKS.PARAGRAPH,
-    data: {},
-    children: []
-  };
-};
-
-function addTableNormalization(editor) {
-  var normalizeNode = editor.normalizeNode;
-
-  editor.normalizeNode = function (entry) {
-    var node = entry[0],
-        path = entry[1]; // TODO: This should be enforced by sanitizeSlateDoc() but the internal
-    // editor value can be different.
-    // cf. https://github.com/ianstormtaylor/slate/issues/2206
-
-    var cellTypes = [BLOCKS.TABLE_CELL, BLOCKS.TABLE_HEADER_CELL];
-
-    if (Element.isElement(node) && cellTypes.includes(node.type)) {
-      for (var _iterator = _createForOfIteratorHelperLoose(Node$1.children(editor, path)), _step; !(_step = _iterator()).done;) {
-        var _step$value = _step.value,
-            child = _step$value[0],
-            childPath = _step$value[1];
-
-        if (Text.isText(child)) {
-          Transforms.wrapNodes(editor, paragraph(), {
-            at: childPath
-          });
-        } else if (!CONTAINERS[node.type].includes(child.type)) {
-          var paragraphWithTextFromNode = _extends({}, paragraph(), {
-            children: [{
-              text: slateNodeToText(child)
-            }]
-          });
-
-          Transforms.removeNodes(editor, {
-            at: childPath
-          });
-          Transforms.insertNodes(editor, paragraphWithTextFromNode, {
-            at: childPath
-          });
-        }
-      }
-    }
-
-    normalizeNode(entry);
-  };
-}
-
 function hasTables(nodes) {
   return nodes.some(function (_ref2) {
     var type = _ref2.type;
@@ -3819,10 +4034,8 @@ function hasHeadersOutsideFirstRow(nodes) {
   });
 }
 
-function createWithTableEvents(tracking) {
+function createTableOnKeyDown() {
   return function withTableEvents(editor) {
-    addTableTrackingEvents(editor, tracking);
-    addTableNormalization(editor);
     var handleKeyDownFromPlateUdecode = getTableOnKeyDown()(editor);
     return function handleKeyDown(event) {
       if (event.key === 'Backspace' && currentSelectionStartsTableCell(editor) || event.key === 'Delete' && currentSelectionPrecedesTableCell(editor)) {
@@ -3841,8 +4054,10 @@ function createWithTableEvents(tracking) {
 
 var createTablePlugin = function createTablePlugin(tracking) {
   return _extends({}, createTablePlugin$1(), {
-    onKeyDown: createWithTableEvents(tracking),
+    onKeyDown: createTableOnKeyDown(),
     withOverrides: function withOverrides(editor) {
+      addTableTrackingEvents(editor, tracking);
+      addTableNormalizers(editor);
       var insertFragment = editor.insertFragment;
 
       editor.insertFragment = function (fragments) {
@@ -4295,16 +4510,15 @@ function getWithEmbeddedEntityEvents(nodeType, sdk) {
     // TODO: Dry up copied code from HR
     return function handleEvent(event) {
       if (!editor) return;
-      var isEnter = event.keyCode === 13;
 
       var _getNodeEntryFromSele = getNodeEntryFromSelection(editor, nodeType),
           pathToSelectedElement = _getNodeEntryFromSele[1];
 
       if (pathToSelectedElement) {
-        if (isEnter) {
-          event.preventDefault();
-          moveToTheNextLine(editor);
-        } else if (event.key === 'Backspace') {
+        var isDelete = event.key === 'Delete';
+        var isBackspace = event.key === 'Backspace';
+
+        if (isDelete || isBackspace) {
           event.preventDefault();
           Transforms.removeNodes(editor, {
             at: pathToSelectedElement
@@ -4753,6 +4967,9 @@ var Toolbar = function Toolbar(_ref) {
   var validationInfo = React__default.useMemo(function () {
     return getValidationInfo(sdk.field);
   }, [sdk.field]);
+  var isListSelected = isNodeTypeSelected(editor, BLOCKS.UL_LIST) || isNodeTypeSelected(editor, BLOCKS.OL_LIST);
+  var isBlockquoteSelected = isNodeTypeSelected(editor, BLOCKS.QUOTE);
+  var shouldDisableTables = isDisabled || !canInsertBlocks || isListSelected || isBlockquoteSelected;
   return /*#__PURE__*/React__default.createElement(Flex, {
     testId: "toolbar",
     className: styles$k.toolbar,
@@ -4784,7 +5001,7 @@ var Toolbar = function Toolbar(_ref) {
   }), isNodeTypeEnabled(sdk.field, BLOCKS.HR) && /*#__PURE__*/React__default.createElement(ToolbarHrButton, {
     isDisabled: isDisabled || !canInsertBlocks
   }), isNodeTypeEnabled(sdk.field, BLOCKS.TABLE) && /*#__PURE__*/React__default.createElement(ToolbarTableButton, {
-    isDisabled: isDisabled || !canInsertBlocks
+    isDisabled: shouldDisableTables
   })), /*#__PURE__*/React__default.createElement("div", {
     className: styles$k.embedActionsWrapper
   }, /*#__PURE__*/React__default.createElement(EmbedEntityWidget, {
@@ -4823,6 +5040,99 @@ var StickyToolbarWrapper = function StickyToolbarWrapper(_ref) {
   }, children);
 };
 
+var TEXT_PARENT_NODES = /*#__PURE__*/VOID_BLOCKS.concat(values(INLINES)).concat(BLOCKS.PARAGRAPH, BLOCKS.HEADING_1, BLOCKS.HEADING_2, BLOCKS.HEADING_3, BLOCKS.HEADING_4, BLOCKS.HEADING_5, BLOCKS.HEADING_6);
+
+var isTextElement = function isTextElement(node) {
+  return 'text' in node;
+};
+
+var wrapNode = function wrapNode(type, node) {
+  return {
+    type: type,
+    data: {},
+    children: [node]
+  };
+};
+
+function wrapOrphanedTextNode(parentNodeType, node) {
+  var paragraph = wrapNode(BLOCKS.PARAGRAPH, node);
+
+  switch (parentNodeType) {
+    case BLOCKS.OL_LIST:
+    case BLOCKS.UL_LIST:
+      return wrapNode(BLOCKS.LIST_ITEM, paragraph);
+
+    case BLOCKS.TABLE_ROW:
+      return wrapNode(BLOCKS.TABLE_CELL, paragraph);
+
+    case BLOCKS.TABLE:
+      return wrapNode(BLOCKS.TABLE_ROW, wrapNode(BLOCKS.TABLE_CELL, paragraph));
+
+    default:
+      return paragraph;
+  }
+}
+/**
+ * Ensures "orphaned" text node elements (those without a parent capable of
+ * validly rendering a text child node) are wrapped with a suitable parent
+ * element to prevent failures on the validation layer.
+ *
+ * It is commonplace for third party plugins (including udecode) to reconcile
+ * deletion events by inserting such nodes into their schema. This
+ * subprocedure is intended as a guard against such cases.
+ */
+
+
+function sanitizeSlateDoc(nodes, parentNodeType) {
+  if (nodes === void 0) {
+    nodes = [];
+  }
+
+  if (parentNodeType === void 0) {
+    parentNodeType = BLOCKS.DOCUMENT;
+  }
+
+  return nodes.map(function (node) {
+    if (isTextElement(node)) {
+      return TEXT_PARENT_NODES.includes(parentNodeType) ? node : wrapOrphanedTextNode(parentNodeType, node);
+    }
+
+    return _extends({}, node, {
+      children: sanitizeSlateDoc(node.children, node.type)
+    });
+  });
+}
+/**
+ * Ensures incoming void nodes have a child leaf text element.
+ */
+
+function sanitizeIncomingSlateDoc(nodes) {
+  if (nodes === void 0) {
+    nodes = [];
+  }
+
+  return nodes.map(function (node) {
+    var _node$children;
+
+    if (isTextElement(node)) {
+      return node;
+    }
+
+    if (node.isVoid && ((_node$children = node.children) == null ? void 0 : _node$children.length) === 0) {
+      return _extends({}, node, {
+        children: [{
+          text: '',
+          data: {}
+        }]
+      });
+    }
+
+    return _extends({}, node, {
+      children: sanitizeIncomingSlateDoc(node.children)
+    });
+  });
+}
+
 var isHTMLElement = function isHTMLElement(node) {
   return node.nodeType === Node.ELEMENT_NODE;
 };
@@ -4973,28 +5283,25 @@ var htmlToDataTransfer = function htmlToDataTransfer(html) {
   return data;
 };
 
-function withPasteHandling(editor) {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  return function (_event) {
-    var insertData = editor.insertData;
+var createPastePlugin = function createPastePlugin() {
+  return {
+    withOverrides: function withOverrides(editor) {
+      var insertData = editor.insertData;
 
-    editor.insertData = function (data) {
-      var html = data.getData(MIME_TYPE_HTML);
+      editor.insertData = function (data) {
+        var html = data.getData(MIME_TYPE_HTML);
 
-      if (html) {
-        var sanitized = sanitizeHtml(html, editor);
-        var newData = htmlToDataTransfer(sanitized);
-        insertData(newData);
-      } else {
-        insertData(data);
-      }
-    };
-  };
-}
+        if (html) {
+          var sanitized = sanitizeHtml(html, editor);
+          var newData = htmlToDataTransfer(sanitized);
+          insertData(newData);
+        } else {
+          insertData(data);
+        }
+      };
 
-var createPastePlugin = function createPastePlugin() {
-  return {
-    onKeyDown: withPasteHandling
+      return editor;
+    }
   };
 };
 
@@ -5129,99 +5436,6 @@ function createInsertBeforeFirstVoidBlockPlugin() {
   return createExitBreakPlugin(optionsExitBreakPlugin);
 }
 
-var TEXT_PARENT_NODES = /*#__PURE__*/VOID_BLOCKS.concat(values(INLINES)).concat(BLOCKS.PARAGRAPH, BLOCKS.HEADING_1, BLOCKS.HEADING_2, BLOCKS.HEADING_3, BLOCKS.HEADING_4, BLOCKS.HEADING_5, BLOCKS.HEADING_6);
-
-var isTextElement = function isTextElement(node) {
-  return 'text' in node;
-};
-
-var wrapNode = function wrapNode(type, node) {
-  return {
-    type: type,
-    data: {},
-    children: [node]
-  };
-};
-
-function wrapOrphanedTextNode(parentNodeType, node) {
-  var paragraph = wrapNode(BLOCKS.PARAGRAPH, node);
-
-  switch (parentNodeType) {
-    case BLOCKS.OL_LIST:
-    case BLOCKS.UL_LIST:
-      return wrapNode(BLOCKS.LIST_ITEM, paragraph);
-
-    case BLOCKS.TABLE_ROW:
-      return wrapNode(BLOCKS.TABLE_CELL, paragraph);
-
-    case BLOCKS.TABLE:
-      return wrapNode(BLOCKS.TABLE_ROW, wrapNode(BLOCKS.TABLE_CELL, paragraph));
-
-    default:
-      return paragraph;
-  }
-}
-/**
- * Ensures "orphaned" text node elements (those without a parent capable of
- * validly rendering a text child node) are wrapped with a suitable parent
- * element to prevent failures on the validation layer.
- *
- * It is commonplace for third party plugins (including udecode) to reconcile
- * deletion events by inserting such nodes into their schema. This
- * subprocedure is intended as a guard against such cases.
- */
-
-
-function sanitizeSlateDoc(nodes, parentNodeType) {
-  if (nodes === void 0) {
-    nodes = [];
-  }
-
-  if (parentNodeType === void 0) {
-    parentNodeType = BLOCKS.DOCUMENT;
-  }
-
-  return nodes.map(function (node) {
-    if (isTextElement(node)) {
-      return TEXT_PARENT_NODES.includes(parentNodeType) ? node : wrapOrphanedTextNode(parentNodeType, node);
-    }
-
-    return _extends({}, node, {
-      children: sanitizeSlateDoc(node.children, node.type)
-    });
-  });
-}
-/**
- * Ensures incoming void nodes have a child leaf text element.
- */
-
-function sanitizeIncomingSlateDoc(nodes) {
-  if (nodes === void 0) {
-    nodes = [];
-  }
-
-  return nodes.map(function (node) {
-    var _node$children;
-
-    if (isTextElement(node)) {
-      return node;
-    }
-
-    if (node.isVoid && ((_node$children = node.children) == null ? void 0 : _node$children.length) === 0) {
-      return _extends({}, node, {
-        children: [{
-          text: '',
-          data: {}
-        }]
-      });
-    }
-
-    return _extends({}, node, {
-      children: sanitizeIncomingSlateDoc(node.children)
-    });
-  });
-}
-
 var createTrailingParagraphPlugin = function createTrailingParagraphPlugin() {
   return createTrailingBlockPlugin({
     type: BLOCKS.PARAGRAPH,
@@ -5233,7 +5447,7 @@ function createDragAndDropPlugin() {
   var _DND_BLOCKED_ELEMENTS;
 
   // Elements that don't allow other elements to be dragged into them and which callback should be used
-  var DND_BLOCKED_ELEMENTS = (_DND_BLOCKED_ELEMENTS = {}, _DND_BLOCKED_ELEMENTS[BLOCKS.TABLE] = Transforms.removeNodes, _DND_BLOCKED_ELEMENTS[BLOCKS.QUOTE] = Transforms.liftNodes, _DND_BLOCKED_ELEMENTS);
+  var DND_BLOCKED_ELEMENTS = (_DND_BLOCKED_ELEMENTS = {}, _DND_BLOCKED_ELEMENTS[BLOCKS.QUOTE] = Transforms.liftNodes, _DND_BLOCKED_ELEMENTS);
   var DRAGGABLE_TYPES = [BLOCKS.EMBEDDED_ENTRY, BLOCKS.EMBEDDED_ASSET, INLINES.EMBEDDED_ENTRY];
   /**
    * HTML node names where dropping should be allowed
@@ -5316,7 +5530,45 @@ function getParents(el) {
   return parents;
 }
 
-var _excluded$1 = ["sdk", "isInitiallyDisabled", "onAction"];
+function createTextPlugin() {
+  return {
+    withOverrides: function withOverrides(editor) {
+      var deleteForward = editor.deleteForward; // When pressing delete instead of backspace
+
+      editor.deleteForward = function (unit) {
+        var _editor$selection;
+
+        var _Editor$nodes = Editor.nodes(editor, {
+          at: (_editor$selection = editor.selection) == null ? void 0 : _editor$selection.focus.path,
+          match: function match(node) {
+            return TEXT_CONTAINERS.includes(node.type);
+          }
+        }),
+            nodes = _Editor$nodes[0];
+
+        if (nodes) {
+          var paragraphOrHeading = nodes[0],
+              path = nodes[1];
+          var isTextEmpty = isAncestorEmpty(editor, paragraphOrHeading); // We ignore paragraphs/headings that are children of ul, ol, blockquote, tables, etc
+
+          var isRootLevel = path.length === 1;
+
+          if (isTextEmpty && isRootLevel) {
+            Transforms.removeNodes(editor, {
+              at: path
+            });
+          } else {
+            deleteForward(unit);
+          }
+        } else {
+          deleteForward(unit);
+        }
+      };
+
+      return editor;
+    }
+  };
+}
 
 var getPlugins = function getPlugins(sdk, tracking) {
   var plugins = [// Core
@@ -5326,16 +5578,16 @@ var getPlugins = function getPlugins(sdk, tracking) {
   createParagraphPlugin(), createListPlugin(), createHrPlugin(), createHeadingPlugin(), createQuotePlugin(), createTablePlugin(tracking), createEmbeddedEntryBlockPlugin(sdk), createEmbeddedAssetBlockPlugin(sdk), // Inline elements
   createHyperlinkPlugin(sdk), createEmbeddedEntityInlinePlugin(sdk), // Marks
   createBoldPlugin(), createCodePlugin(), createItalicPlugin(), createUnderlinePlugin(), // Other
-  createTrailingParagraphPlugin()];
+  createTrailingParagraphPlugin(), createTextPlugin()];
   return plugins.concat([createDeserializeHTMLPlugin({
     plugins: plugins
   }), createDeserializeAstPlugin({
     plugins: plugins
   })]);
 };
+var pluginOptions = /*#__PURE__*/_extends({}, withParagraphOptions, withListOptions, withHrOptions, withHeadingOptions, withQuoteOptions, withTableOptions, withEmbeddedEntryBlockOptions, withEmbeddedAssetBlockOptions, withHyperlinkOptions, withEmbeddedEntityInlineOptions, withBoldOptions, withCodeOptions, withItalicOptions, withUnderlineOptions);
 
-var options = /*#__PURE__*/_extends({}, withParagraphOptions, withListOptions, withHrOptions, withHeadingOptions, withQuoteOptions, withTableOptions, withEmbeddedEntryBlockOptions, withEmbeddedAssetBlockOptions, withHyperlinkOptions, withEmbeddedEntityInlineOptions, withBoldOptions, withCodeOptions, withItalicOptions, withUnderlineOptions);
-
+var _excluded$1 = ["sdk", "isInitiallyDisabled", "onAction"];
 var ConnectedRichTextEditor = function ConnectedRichTextEditor(props) {
   var tracking = useTrackingContext();
   var docFromAdapter = toSlatejsDocument({
@@ -5375,7 +5627,7 @@ var ConnectedRichTextEditor = function ConnectedRichTextEditor(props) {
       props.onChange == null ? void 0 : props.onChange(contentfulDoc);
     },
     // @ts-expect-error
-    options: options
+    options: pluginOptions
   }, !props.isToolbarHidden && /*#__PURE__*/React__default.createElement(StickyToolbarWrapper, {
     isDisabled: props.isDisabled
   }, /*#__PURE__*/React__default.createElement(Toolbar, {