slate-react 0.78.1 → 0.79.0-20224219174

package/dist/index.js

@@ -1279,7 +1279,6 @@ var Editable$1 = function Editable(props) {
 
   var state = React.useMemo(function () {
     return {
-      isComposing: false,
       hasInsertPrefixInCompositon: false,
       isDraggingInternally: false,
       isUpdatingSelection: false,
@@ -1305,7 +1304,7 @@ var Editable$1 = function Editable(props) {
     var root = ReactEditor.findDocumentOrShadowRoot(editor);
     var domSelection = root.getSelection();
 
-    if (state.isComposing || !domSelection || !ReactEditor.isFocused(editor)) {
+    if (ReactEditor.isComposing(editor) || !domSelection || !ReactEditor.isFocused(editor)) {
       return;
     }
 
@@ -1389,7 +1388,7 @@ var Editable$1 = function Editable(props) {
   // while a selection is being dragged.
 
   var onDOMSelectionChange = React.useCallback(throttle__default['default'](function () {
-    if (!state.isComposing && !state.isUpdatingSelection && !state.isDraggingInternally) {
+    if (!ReactEditor.isComposing(editor) && !state.isUpdatingSelection && !state.isDraggingInternally) {
       var root = ReactEditor.findDocumentOrShadowRoot(editor);
       var activeElement = root.activeElement;
       var el = ReactEditor.toDOMNode(editor, editor);
@@ -1641,8 +1640,10 @@ var Editable$1 = function Editable(props) {
               // then we will abort because we're still composing and the selection
               // won't be updated properly.
               // https://www.w3.org/TR/input-events-2/
-              state.isComposing && setIsComposing(false);
-              state.isComposing = false;
+              if (ReactEditor.isComposing(editor)) {
+                setIsComposing(false);
+                IS_COMPOSING.set(editor, false);
+              }
             } // use a weak comparison instead of 'instanceof' to allow
             // programmatic access of paste events coming from external windows
             // like cypress where cy.window does not work realibly
@@ -1762,7 +1763,7 @@ var Editable$1 = function Editable(props) {
       if (!HAS_BEFORE_INPUT_SUPPORT && !readOnly && !isEventHandled(event, attributes.onBeforeInput) && hasEditableTarget(editor, event.target)) {
         event.preventDefault();
 
-        if (!state.isComposing) {
+        if (!ReactEditor.isComposing(editor)) {
           var text = event.data;
           slate.Editor.insertText(editor, text);
         }
@@ -1895,12 +1896,15 @@ var Editable$1 = function Editable(props) {
     }, [readOnly, attributes.onClick]),
     onCompositionEnd: React.useCallback(function (event) {
       if (hasEditableTarget(editor, event.target) && !isEventHandled(event, attributes.onCompositionEnd)) {
-        state.isComposing && setIsComposing(false);
-        state.isComposing = false; // COMPAT: In Chrome, `beforeinput` events for compositions
+        if (ReactEditor.isComposing(editor)) {
+          setIsComposing(false);
+          IS_COMPOSING.set(editor, false);
+        } // COMPAT: In Chrome, `beforeinput` events for compositions
         // aren't correct and never fire the "insertFromComposition"
         // type that we need. So instead, insert whenever a composition
         // ends since it will already have been committed to the DOM.
 
+
         if (!IS_SAFARI && !IS_FIREFOX_LEGACY && !IS_IOS && !IS_QQBROWSER && !IS_WECHATBROWSER && !IS_UC_MOBILE && event.data) {
           slate.Editor.insertText(editor, event.data);
         }
@@ -1926,8 +1930,10 @@ var Editable$1 = function Editable(props) {
     }, [attributes.onCompositionEnd]),
     onCompositionUpdate: React.useCallback(function (event) {
       if (hasEditableTarget(editor, event.target) && !isEventHandled(event, attributes.onCompositionUpdate)) {
-        !state.isComposing && setIsComposing(true);
-        state.isComposing = true;
+        if (!ReactEditor.isComposing(editor)) {
+          setIsComposing(true);
+          IS_COMPOSING.set(editor, true);
+        }
       }
     }, [attributes.onCompositionUpdate]),
     onCompositionStart: React.useCallback(function (event) {
@@ -2094,12 +2100,12 @@ var Editable$1 = function Editable(props) {
         // so we sometimes might end up stuck in a composition state even though we
         // aren't composing any more.
 
-        if (state.isComposing && nativeEvent.isComposing === false) {
-          state.isComposing = false;
+        if (ReactEditor.isComposing(editor) && nativeEvent.isComposing === false) {
+          IS_COMPOSING.set(editor, false);
           setIsComposing(false);
         }
 
-        if (isEventHandled(event, attributes.onKeyDown) || state.isComposing) {
+        if (isEventHandled(event, attributes.onKeyDown) || ReactEditor.isComposing(editor)) {
           return;
         }
 
@@ -2744,6 +2750,13 @@ var Key = function Key() {
 };
 
 var ReactEditor = {
+  /**
+   * Check if the user is currently composing inside the editor.
+   */
+  isComposing: function isComposing(editor) {
+    return !!IS_COMPOSING.get(editor);
+  },
+
   /**
    * Return the host window of the current editor.
    */
@@ -3517,7 +3530,7 @@ var AndroidInputManager = function AndroidInputManager(editor, restoreDOM) {
     var selection = _this.editor.selection; // If it is in composing or after `onCompositionend`, set `EDITOR_ON_COMPOSITION_TEXT` and return.
     // Text will be inserted on compositionend event.
 
-    if (IS_COMPOSING.get(_this.editor) || IS_ON_COMPOSITION_END.get(_this.editor)) {
+    if (ReactEditor.isComposing(_this.editor) || IS_ON_COMPOSITION_END.get(_this.editor)) {
       EDITOR_ON_COMPOSITION_TEXT.set(_this.editor, insertedText);
       IS_ON_COMPOSITION_END.set(_this.editor, false);
       return;