@contentful/field-editor-rich-text 2.0.0-next.18 → 2.0.0-next.19

package/dist/field-editor-rich-text.cjs.development.js

@@ -425,6 +425,23 @@ function moveToTheNextLine(editor) {
     unit: 'line'
   });
 }
+function moveToTheNextChar(editor) {
+  slate.Transforms.move(editor, {
+    distance: 1,
+    unit: 'character'
+  });
+}
+function insertEmptyParagraph(editor) {
+  var emptyParagraph = {
+    type: Contentful.BLOCKS.PARAGRAPH,
+    children: [{
+      text: ''
+    }],
+    data: {},
+    isVoid: false
+  };
+  slate.Transforms.insertNodes(editor, emptyParagraph);
+}
 function getElementFromCurrentSelection(editor) {
   if (!editor.selection) return [];
   return Array.from(slate.Editor.nodes(editor, {
@@ -1943,11 +1960,12 @@ function _selectEntityAndInsert() {
           case 12:
             slate.Transforms.select(editor, selection);
             insertBlock(editor, nodeType, entity);
+            ensureFollowingParagraph(editor);
             logAction('insert', {
               nodeType: nodeType
             });
 
-          case 15:
+          case 16:
           case "end":
             return _context.stop();
         }
@@ -1957,6 +1975,43 @@ function _selectEntityAndInsert() {
   return _selectEntityAndInsert.apply(this, arguments);
 }
 
+function ensureFollowingParagraph(editor) {
+  /*
+     If the new block isn't followed by a sibling paragraph we insert a new empty one
+   */
+  var next = slate.Editor.next(editor);
+
+  if (!next) {
+    return insertEmptyParagraph(editor);
+  }
+
+  var parent = slate.Editor.above(editor, {
+    voids: false,
+    match: function match(e) {
+      return !slate.Element.isElement(e) || ![Contentful.BLOCKS.EMBEDDED_ASSET, Contentful.BLOCKS.EMBEDDED_ENTRY].includes(e.type);
+    }
+  });
+
+  if (slate.Editor.isEditor(parent)) {
+    // at level 0, a following paragraph is handled by the tralingParagraph plugin
+    moveToTheNextChar(editor);
+    return;
+  }
+
+  var paragraph = slate.Editor.above(editor, {
+    at: next[1],
+    match: function match(e) {
+      return slate.Element.isElement(e) && Contentful.TEXT_CONTAINERS.includes(e.type);
+    }
+  });
+
+  if (!paragraph || !parent || !slate.Path.isChild(paragraph[1], parent[1])) {
+    return insertEmptyParagraph(editor);
+  }
+
+  moveToTheNextChar(editor);
+}
+
 var createNode = function createNode(nodeType, entity) {
   return {
     type: nodeType,
@@ -2004,11 +2059,29 @@ function EmbeddedEntityBlockToolbarIcon(_ref) {
   var editor = useContentfulEditor();
   var sdk = useSdkContext();
 
-  var handleClick = function handleClick(event) {
-    event.preventDefault();
-    onClose();
-    selectEntityAndInsert(nodeType, sdk, editor, editor.tracking.onToolbarAction);
-  };
+  var handleClick = /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(event) {
+      return runtime_1.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              event.preventDefault();
+              onClose();
+              _context.next = 4;
+              return selectEntityAndInsert(nodeType, sdk, editor, editor.tracking.onToolbarAction);
+
+            case 4:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function handleClick(_x) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
 
   var type = getEntityTypeFromNodeType(nodeType);
   var baseClass = "rich-text__" + nodeType;
@@ -2341,15 +2414,18 @@ function _selectEntityAndInsert$1() {
             return _context2.abrupt("return");
 
           case 10:
-            inlineEntryNode = createInlineEntryNode(entry.sys.id); // Got to wait until focus is really back on the editor or setSelection() won't work.
-
-            setTimeout(function () {
-              slate.Transforms.setSelection(editor, selection);
-              slate.Transforms.insertNodes(editor, inlineEntryNode);
-            }, 0);
+            inlineEntryNode = createInlineEntryNode(entry.sys.id);
             logAction('insert', {
               nodeType: Contentful.INLINES.EMBEDDED_ENTRY
-            });
+            }); // Got to wait until focus is really back on the editor or setSelection() won't work.
+
+            return _context2.abrupt("return", new Promise(function (resolve) {
+              setTimeout(function () {
+                slate.Transforms.setSelection(editor, selection);
+                slate.Transforms.insertNodes(editor, inlineEntryNode);
+                resolve();
+              }, 0);
+            }));
 
           case 13:
           case "end":
@@ -2390,6 +2466,9 @@ function ToolbarEmbeddedEntityInlineButton(props) {
               return selectEntityAndInsert$1(editor, sdk, editor.tracking.onToolbarAction);
 
             case 6:
+              moveToTheNextChar(editor);
+
+            case 7:
             case "end":
               return _context.stop();
           }
@@ -4998,10 +5077,6 @@ function toggleQuote(editor, logAction) {
       },
       split: true
     });
-    var _editor$selection = editor.selection,
-        anchor = _editor$selection.anchor,
-        focus = _editor$selection.focus;
-    var isTripleSelection = anchor.path[0] !== focus.path[0] && anchor.offset === 0 && focus.offset === 0;
 
     if (!isActive) {
       var quote = {
@@ -5009,9 +5084,7 @@ function toggleQuote(editor, logAction) {
         data: {},
         children: []
       };
-      slate.Transforms.wrapNodes(editor, quote, {
-        at: isTripleSelection ? editor.selection.anchor : undefined
-      });
+      slate.Transforms.wrapNodes(editor, quote);
     }
   });
 }
@@ -5588,15 +5661,7 @@ var createTablePlugin = function createTablePlugin() {
         });
 
         if (fragmentHasTable) {
-          var emptyParagraph = {
-            type: Contentful.BLOCKS.PARAGRAPH,
-            children: [{
-              text: ''
-            }],
-            data: {},
-            isVoid: false
-          };
-          slate.Transforms.insertNodes(editor, emptyParagraph);
+          insertEmptyParagraph(editor);
         }
 
         insertFragment(fragments);
@@ -5725,6 +5790,20 @@ function ToolbarTableButton(props) {
 function createTextPlugin() {
   return {
     key: 'TextPlugin',
+    handlers: {
+      // Triple selection in a non-Firefox browser undesirably selects
+      // the start of the next block. Editor.unhangRange helps removing
+      // the extra block at the end.
+      onMouseUp: function onMouseUp(editor) {
+        return function () {
+          if (!editor.selection) {
+            return;
+          }
+
+          slate.Transforms.setSelection(editor, slate.Editor.unhangRange(editor, editor.selection));
+        };
+      }
+    },
     withOverrides: function withOverrides(editor) {
       // Reverts the change made upstream that caused the cursor
       // to be trapped inside inline elements.
@@ -6336,7 +6415,10 @@ var useNormalizedSlateValue = function useNormalizedSlateValue(_ref) {
       schema: schema
     }); // Sets editor value & kicks normalization
 
-    slate.Transforms.insertNodes(editor, doc); // TODO: return the editor itself to avoid recompiling & initializing all
+    editor.children = doc;
+    slate.Editor.normalize(editor, {
+      force: true
+    }); // TODO: return the editor itself to avoid recompiling & initializing all
     // of the plugins again. It's currently not possible due to a bug in Plate
     // with initialValues
     // See: https://slate-js.slack.com/archives/C013QHXSCG1/p1645112799942819