slate-react 0.140.0 → 0.140.1

package/dist/index.js

@@ -3356,6 +3356,9 @@ function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r)
 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(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 slateDom.isDOMNode(node) && node.nodeType === 3;
+};
 var isSameCaretPosition = function isSameCaretPosition(editor, a, b) {
   if (!slate.Range.isCollapsed(a) || !slate.Range.isCollapsed(b)) {
     return false;
@@ -3414,6 +3417,7 @@ var Editable = /*#__PURE__*/React.forwardRef(function (props, forwardedRef) {
   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],
@@ -3768,6 +3772,7 @@ var Editable = /*#__PURE__*/React.forwardRef(function (props, forwardedRef) {
         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
@@ -3777,14 +3782,14 @@ var Editable = /*#__PURE__*/React.forwardRef(function (props, forwardedRef) {
       // 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 = slateDom.getSelection(ReactEditor.findDocumentOrShadowRoot(editor))) === null || _getSelection === void 0 ? void 0 : _getSelection.anchorNode;
+        var domSelection = slateDom.getSelection(ReactEditor.findDocumentOrShadowRoot(editor));
+        var domAnchor = domSelection === null || domSelection === void 0 ? void 0 : domSelection.anchorNode;
         if (!isInSlateText(domAnchor)) {
           _native = false;
         }
@@ -3821,6 +3826,9 @@ var Editable = /*#__PURE__*/React.forwardRef(function (props, forwardedRef) {
               _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
@@ -3847,6 +3855,9 @@ var Editable = /*#__PURE__*/React.forwardRef(function (props, forwardedRef) {
               slateDom.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
@@ -3855,6 +3866,7 @@ var Editable = /*#__PURE__*/React.forwardRef(function (props, forwardedRef) {
         return;
       }
       if (!_native) {
+        lastNativeInsertion.current = null;
         event.preventDefault();
       }
       // COMPAT: If the selection is expanded, even if the command seems like
@@ -3972,6 +3984,24 @@ var Editable = /*#__PURE__*/React.forwardRef(function (props, forwardedRef) {
               // 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);
                 });
@@ -4233,6 +4263,24 @@ var Editable = /*#__PURE__*/React.forwardRef(function (props, forwardedRef) {
         _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 = slateDom.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,