slate-react 0.140.0 → 0.140.1

package/dist/slate-react.js

@@ -7331,6 +7331,9 @@
 	function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 	function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 	function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), true).forEach(function (r) { _defineProperty$1(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+	var isTextDOMNode = function isTextDOMNode(node) {
+	  return isDOMNode(node) && node.nodeType === 3;
+	};
 	var isSameCaretPosition = function isSameCaretPosition(editor, a, b) {
 	  if (!slate.Range.isCollapsed(a) || !slate.Range.isCollapsed(b)) {
 	    return false;
@@ -7389,6 +7392,7 @@
 	  var pendingInputScroll = React.useRef(false);
 	  var pendingNavigationScroll = React.useRef(false);
 	  var deferredOperations = React.useRef([]);
+	  var lastNativeInsertion = React.useRef(null);
 	  var _useState3 = React.useState(),
 	    _useState4 = _slicedToArray(_useState3, 2),
 	    placeholderHeight = _useState4[0],
@@ -7743,6 +7747,7 @@
 	        return;
 	      }
 	      var _native = false;
+	      var nativePoint = null;
 	      if (type === 'insertText' && selection && slate.Range.isCollapsed(selection) &&
 	      // Only use native character insertion for single characters a-z or space for now.
 	      // Long-press events (hold a + press 4 = ä) to choose a special character otherwise
@@ -7752,14 +7757,14 @@
 	      // When there is an inline element, e.g. a link, and you select
 	      // right after it (the start of the next node).
 	      selection.anchor.offset !== 0) {
-	        var _getSelection;
 	        _native = true;
 	        // Skip native if there are marks, as
 	        // `insertText` will insert a node, not just text.
 	        if (editor.marks) {
 	          _native = false;
 	        }
-	        var domAnchor = (_getSelection = getSelection(ReactEditor.findDocumentOrShadowRoot(editor))) === null || _getSelection === void 0 ? void 0 : _getSelection.anchorNode;
+	        var domSelection = getSelection(ReactEditor.findDocumentOrShadowRoot(editor));
+	        var domAnchor = domSelection === null || domSelection === void 0 ? void 0 : domSelection.anchorNode;
 	        if (!isInSlateText(domAnchor)) {
 	          _native = false;
 	        }
@@ -7796,6 +7801,9 @@
 	              _native = false;
 	            }
 	          }
+	          if (_native && isTextDOMNode(node)) {
+	            nativePoint = domSelection !== null && domSelection !== void 0 && domSelection.isCollapsed && isTextDOMNode(domAnchor) ? [domAnchor, domSelection.anchorOffset] : [node, offset];
+	          }
 	        }
 	      }
 	      // COMPAT: For the deleting forward/backward input types we don't want
@@ -7822,6 +7830,9 @@
 	              EDITOR_TO_USER_SELECTION.set(editor, selectionRef);
 	            }
 	          }
+	          if (_native && isTextDOMNode(targetRange.startContainer)) {
+	            nativePoint = [targetRange.startContainer, targetRange.startOffset];
+	          }
 	        }
 	      }
 	      // Composition change types occur while a user is composing text and can't be
@@ -7830,6 +7841,7 @@
 	        return;
 	      }
 	      if (!_native) {
+	        lastNativeInsertion.current = null;
 	        event.preventDefault();
 	      }
 	      // COMPAT: If the selection is expanded, even if the command seems like
@@ -7947,6 +7959,24 @@
 	              // Only insertText operations use the native functionality, for now.
 	              // Potentially expand to single character deletes, as well.
 	              if (_native) {
+	                lastNativeInsertion.current = null;
+	                if (nativePoint && selection) {
+	                  var _Editor$leaf = slate.Editor.leaf(editor, selection.anchor),
+	                    _Editor$leaf2 = _slicedToArray(_Editor$leaf, 1),
+	                    _node = _Editor$leaf2[0];
+	                  var _nativePoint = nativePoint,
+	                    _nativePoint2 = _slicedToArray(_nativePoint, 2),
+	                    domNode = _nativePoint2[0],
+	                    domOffset = _nativePoint2[1];
+	                  lastNativeInsertion.current = {
+	                    point: selection.anchor,
+	                    text: _node.text,
+	                    domNode: domNode,
+	                    domOffset: domOffset,
+	                    domText: domNode.data,
+	                    "char": data
+	                  };
+	                }
 	                deferredOperations.current.push(function () {
 	                  return slate.Editor.insertText(editor, data);
 	                });
@@ -8208,6 +8238,24 @@
 	        _iterator.f();
 	      }
 	      deferredOperations.current = [];
+	      var nativeInsertion = lastNativeInsertion.current;
+	      lastNativeInsertion.current = null;
+	      if (nativeInsertion) {
+	        var point = nativeInsertion.point,
+	          _text3 = nativeInsertion.text,
+	          domNode = nativeInsertion.domNode,
+	          domOffset = nativeInsertion.domOffset,
+	          domText = nativeInsertion.domText,
+	          _char = nativeInsertion["char"];
+	        var node = slate.Node.getIf(editor, point.path);
+	        if (slate.Text.isText(node) && node.text === _text3 && domNode.isConnected && domNode.data === domText.slice(0, domOffset) + _char + domText.slice(domOffset)) {
+	          domNode.deleteData(domOffset, _char.length);
+	          if (editor.selection && slate.Range.isCollapsed(editor.selection) && slate.Point.equals(editor.selection.anchor, point)) {
+	            var _getSelection;
+	            (_getSelection = getSelection(ReactEditor.findDocumentOrShadowRoot(editor))) === null || _getSelection === void 0 || _getSelection.collapse(domNode, domOffset);
+	          }
+	        }
+	      }
 	      // COMPAT: Since `beforeinput` doesn't fully `preventDefault`,
 	      // there's a chance that content might be placed in the browser's undo stack.
 	      // This means undo can be triggered even when the div is not focused,