@portabletext/editor 1.30.1 → 1.30.3

package/lib/_chunks-es/plugin.event-listener.js

@@ -5,7 +5,7 @@ import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import { withReact, ReactEditor, Slate } from "slate-react";
 import { useSelector, useActorRef } from "@xstate/react";
 import debug$f from "debug";
-import { Editor, Element, Range, Point, Text, Operation, Transforms, Path, Node, createEditor as createEditor$1, select, deleteFragment, insertText, deleteBackward, deleteForward } from "slate";
+import { Editor, Element, Range, Point, Text, Operation, Transforms, Path, Node, insertText, createEditor as createEditor$1, select, deleteFragment, deleteBackward, deleteForward } from "slate";
 import { setup, emit, assign, fromCallback, assertEvent, enqueueActions, createActor } from "xstate";
 import isEqual from "lodash/isEqual.js";
 import { unset, set, setIfMissing, insert, diffMatchPatch as diffMatchPatch$1, applyAll } from "@portabletext/patches";
@@ -24,7 +24,7 @@ import omitBy from "lodash/omitBy.js";
 import startCase from "lodash.startcase";
 import { createGuards } from "./selector.is-at-the-start-of-block.js";
 import { blockOffsetToSpanSelectionPoint } from "./util.is-empty-text-block.js";
-import { coreBehaviors, isCustomBehaviorEvent } from "./behavior.core.js";
+import { defineBehavior, raise, coreBehaviors, isCustomBehaviorEvent } from "./behavior.core.js";
 import getRandomValues from "get-random-values-esm";
 import { Subject } from "rxjs";
 function createEditorSchema(portableTextType) {
@@ -1678,7 +1678,7 @@ function findOperationTargetBlock(editor, operation) {
   let block;
   return operation.type === "set_selection" && editor.selection ? block = editor.children[editor.selection.focus.path[0]] : "path" in operation && (block = editor.children[operation.path[0]]), block;
 }
-const syncValueCallback = ({
+const debug$d = debugWithName("sync machine"), syncValueCallback = ({
   sendBack,
   input
 }) => {
@@ -1728,7 +1728,15 @@ const syncValueCallback = ({
     }) => context.initialValueSynced,
     "is busy": ({
       context
-    }) => !context.readOnly && (context.isProcessingLocalChanges || (isChangingRemotely(context.slateEditor) ?? !1)),
+    }) => {
+      const editable = !context.readOnly, isProcessingLocalChanges = context.isProcessingLocalChanges, isChanging = isChangingRemotely(context.slateEditor) ?? !1, isBusy = editable && (isProcessingLocalChanges || isChanging);
+      return debug$d("isBusy", {
+        isBusy,
+        editable,
+        isProcessingLocalChanges,
+        isChanging
+      }), isBusy;
+    },
     "value changed while syncing": ({
       context,
       event
@@ -1775,13 +1783,24 @@ const syncValueCallback = ({
       initial: "syncing initial value",
       states: {
         "syncing initial value": {
+          entry: [() => {
+            debug$d("entry: syncing initial value");
+          }],
+          exit: [() => {
+            debug$d("exit: syncing initial value");
+          }],
           always: {
             guard: "initial value synced",
             target: "done syncing initial value"
           }
         },
         "done syncing initial value": {
-          entry: ["emit done syncing initial value"],
+          entry: ["emit done syncing initial value", () => {
+            debug$d("entry: done syncing initial value");
+          }],
+          exit: [() => {
+            debug$d("exit: done syncing initial value");
+          }],
           type: "final"
         }
       }
@@ -1790,6 +1809,12 @@ const syncValueCallback = ({
       initial: "idle",
       states: {
         idle: {
+          entry: [() => {
+            debug$d("entry: syncing->idle");
+          }],
+          exit: [() => {
+            debug$d("exit: syncing->idle");
+          }],
           on: {
             "update value": [{
               guard: "is busy",
@@ -1802,10 +1827,20 @@ const syncValueCallback = ({
           }
         },
         busy: {
+          entry: [() => {
+            debug$d("entry: syncing->busy");
+          }],
+          exit: [() => {
+            debug$d("exit: syncing->busy");
+          }],
           after: {
             1e3: [{
               guard: "is busy",
-              reenter: !0
+              target: ".",
+              reenter: !0,
+              actions: [() => {
+                debug$d("reenter: syncing->busy");
+              }]
             }, {
               target: "syncing"
             }]
@@ -1817,6 +1852,12 @@ const syncValueCallback = ({
           }
         },
         syncing: {
+          entry: [() => {
+            debug$d("entry: syncing->syncing");
+          }],
+          exit: [() => {
+            debug$d("exit: syncing->syncing");
+          }],
           always: {
             guard: "pending value equals previous value",
             target: "idle",
@@ -1871,7 +1912,7 @@ const syncValueCallback = ({
       }
     }
   }
-}), debug$d = debugWithName("hook:useSyncValue");
+});
 async function updateValue({
   context,
   sendBack,
@@ -2608,7 +2649,74 @@ function createOperationToPatches(types) {
     splitNodePatch
   };
 }
-const IS_APPLYING_BEHAVIOR_ACTIONS = /* @__PURE__ */ new WeakMap();
+const insertBreakActionImplementation = ({
+  context,
+  action
+}) => {
+  const keyGenerator = context.keyGenerator, schema = context.schema, editor = action.editor;
+  if (!editor.selection)
+    return;
+  const anchorBlockPath = editor.selection.anchor.path.slice(0, 1), focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = Node.descendant(editor, focusBlockPath);
+  if (editor.isTextBlock(focusBlock) && anchorBlockPath[0] === focusBlockPath[0]) {
+    Transforms.splitNodes(editor, {
+      at: editor.selection
+    });
+    const [nextBlock, nextBlockPath] = Editor.node(editor, Path.next(focusBlockPath), {
+      depth: 1
+    }), nextChild = Node.child(nextBlock, 0);
+    if (!editor.isTextSpan(nextChild) && Transforms.insertNodes(editor, {
+      _key: context.keyGenerator(),
+      _type: "span",
+      text: "",
+      marks: []
+    }, {
+      at: [nextBlockPath[0], 0]
+    }), Transforms.setSelection(editor, {
+      anchor: {
+        path: [...nextBlockPath, 0],
+        offset: 0
+      },
+      focus: {
+        path: [...nextBlockPath, 0],
+        offset: 0
+      }
+    }), editor.isTextBlock(nextBlock) && nextBlock.markDefs && nextBlock.markDefs.length > 0) {
+      const newMarkDefKeys = /* @__PURE__ */ new Map(), prevNodeSpans = Array.from(Node.children(editor, focusBlockPath)).map((entry) => entry[0]).filter((node) => editor.isTextSpan(node)), children = Node.children(editor, nextBlockPath);
+      for (const [child, childPath] of children) {
+        if (!editor.isTextSpan(child))
+          continue;
+        const marks = child.marks ?? [];
+        for (const mark of marks)
+          schema.decorators.some((decorator) => decorator.value === mark) || prevNodeSpans.some((prevNodeSpan) => prevNodeSpan.marks?.includes(mark)) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(mark, keyGenerator());
+        const newMarks = marks.map((mark) => newMarkDefKeys.get(mark) ?? mark);
+        isEqual(marks, newMarks) || Transforms.setNodes(editor, {
+          marks: newMarks
+        }, {
+          at: childPath
+        });
+      }
+      const newMarkDefs = nextBlock.markDefs.map((markDef) => ({
+        ...markDef,
+        _key: newMarkDefKeys.get(markDef._key) ?? markDef._key
+      }));
+      isEqual(nextBlock.markDefs, newMarkDefs) || Transforms.setNodes(editor, {
+        markDefs: newMarkDefs
+      }, {
+        at: nextBlockPath,
+        match: (node) => editor.isTextBlock(node)
+      });
+    }
+    return;
+  }
+  Transforms.splitNodes(editor, {
+    always: !0
+  });
+}, insertSoftBreakActionImplementation = ({
+  action
+}) => {
+  insertText(action.editor, `
+`);
+}, IS_APPLYING_BEHAVIOR_ACTIONS = /* @__PURE__ */ new WeakMap();
 function withApplyingBehaviorActions(editor, fn) {
   const prev = isApplyingBehaviorActions(editor);
   IS_APPLYING_BEHAVIOR_ACTIONS.set(editor, !0), fn(), IS_APPLYING_BEHAVIOR_ACTIONS.set(editor, prev);
@@ -2665,7 +2773,6 @@ function createWithEventListeners(editorActor, subscriptions) {
       deleteForward: deleteForward2,
       insertBreak,
       insertData,
-      insertSoftBreak,
       insertText: insertText2,
       select: select2,
       setFragmentData
@@ -2723,7 +2830,16 @@ function createWithEventListeners(editorActor, subscriptions) {
       });
     }, editor.insertSoftBreak = () => {
       if (isApplyingBehaviorActions(editor)) {
-        insertSoftBreak();
+        insertSoftBreakActionImplementation({
+          context: {
+            keyGenerator: editorActor.getSnapshot().context.keyGenerator,
+            schema: editorActor.getSnapshot().context.schema
+          },
+          action: {
+            type: "insert.soft break",
+            editor
+          }
+        });
         return;
       }
       editorActor.send({
@@ -4798,73 +4914,6 @@ const blockSetBehaviorActionImplementation = ({
   }), action.editor.insertFragment(fragment), Transforms.removeNodes(action.editor, {
     at: [0]
   })) : action.editor.insertFragment(fragment);
-}, insertBreakActionImplementation = ({
-  context,
-  action
-}) => {
-  const keyGenerator = context.keyGenerator, schema = context.schema, editor = action.editor;
-  if (!editor.selection)
-    return;
-  const anchorBlockPath = editor.selection.anchor.path.slice(0, 1), focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = Node.descendant(editor, focusBlockPath);
-  if (editor.isTextBlock(focusBlock) && anchorBlockPath[0] === focusBlockPath[0]) {
-    Transforms.splitNodes(editor, {
-      at: editor.selection
-    });
-    const [nextBlock, nextBlockPath] = Editor.node(editor, Path.next(focusBlockPath), {
-      depth: 1
-    }), nextChild = Node.child(nextBlock, 0);
-    if (!editor.isTextSpan(nextChild) && Transforms.insertNodes(editor, {
-      _key: context.keyGenerator(),
-      _type: "span",
-      text: "",
-      marks: []
-    }, {
-      at: [nextBlockPath[0], 0]
-    }), Transforms.setSelection(editor, {
-      anchor: {
-        path: [...nextBlockPath, 0],
-        offset: 0
-      },
-      focus: {
-        path: [...nextBlockPath, 0],
-        offset: 0
-      }
-    }), editor.isTextBlock(nextBlock) && nextBlock.markDefs && nextBlock.markDefs.length > 0) {
-      const newMarkDefKeys = /* @__PURE__ */ new Map(), prevNodeSpans = Array.from(Node.children(editor, focusBlockPath)).map((entry) => entry[0]).filter((node) => editor.isTextSpan(node)), children = Node.children(editor, nextBlockPath);
-      for (const [child, childPath] of children) {
-        if (!editor.isTextSpan(child))
-          continue;
-        const marks = child.marks ?? [];
-        for (const mark of marks)
-          schema.decorators.some((decorator) => decorator.value === mark) || prevNodeSpans.some((prevNodeSpan) => prevNodeSpan.marks?.includes(mark)) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(mark, keyGenerator());
-        const newMarks = marks.map((mark) => newMarkDefKeys.get(mark) ?? mark);
-        isEqual(marks, newMarks) || Transforms.setNodes(editor, {
-          marks: newMarks
-        }, {
-          at: childPath
-        });
-      }
-      const newMarkDefs = nextBlock.markDefs.map((markDef) => ({
-        ...markDef,
-        _key: newMarkDefKeys.get(markDef._key) ?? markDef._key
-      }));
-      isEqual(nextBlock.markDefs, newMarkDefs) || Transforms.setNodes(editor, {
-        markDefs: newMarkDefs
-      }, {
-        at: nextBlockPath,
-        match: (node) => editor.isTextBlock(node)
-      });
-    }
-    return;
-  }
-  Transforms.splitNodes(editor, {
-    always: !0
-  });
-}, insertSoftBreakActionImplementation = ({
-  action
-}) => {
-  insertText(action.editor, `
-`);
 }, insertInlineObjectActionImplementation = ({
   context,
   action
@@ -5556,6 +5605,24 @@ function performDefaultAction({
       });
   }
 }
+const keyIs = {
+  lineBreak: (event) => event.key === "Enter" && event.shiftKey
+}, foundationalBehaviors = [
+  /**
+   * On WebKit, Shift+Enter results in an `insertParagraph` input event rather
+   * than an `insertLineBreak` input event. This Behavior makes sure we catch
+   * that `key.down` event beforehand and raise an `insert.soft break` manually.
+   */
+  defineBehavior({
+    on: "key.down",
+    guard: ({
+      event
+    }) => keyIs.lineBreak(event.keyboardEvent),
+    actions: [() => [raise({
+      type: "insert.soft break"
+    })]]
+  })
+];
 function getActiveDecorators({
   schema,
   slateEditorInstance
@@ -5609,7 +5676,7 @@ const editorMachine = setup({
     "assign behaviors": assign({
       behaviors: ({
         event
-      }) => (assertEvent(event, "update behaviors"), new Set(event.behaviors))
+      }) => (assertEvent(event, "update behaviors"), /* @__PURE__ */ new Set([...foundationalBehaviors, ...event.behaviors]))
     }),
     "assign schema": assign({
       schema: ({
@@ -5776,7 +5843,7 @@ const editorMachine = setup({
   context: ({
     input
   }) => ({
-    behaviors: new Set(input.behaviors ?? coreBehaviors),
+    behaviors: /* @__PURE__ */ new Set([...foundationalBehaviors, ...input.behaviors ?? coreBehaviors]),
     converters: new Set(input.converters ?? []),
     keyGenerator: input.keyGenerator,
     pendingEvents: [],
@@ -6617,7 +6684,7 @@ class PortableTextEditor extends Component {
    * const selectedSlice = useEditorSelector(editor, selectors.getSelectedSlice)
    * ```
    */
-  static getFragment = (editor) => (debug("Host getting fragment"), editor.editable?.getFragment());
+  static getFragment = (editor) => editor.editable?.getFragment();
   static undo = (editor) => {
     debug("Host undoing"), editor.editable?.undo();
   };