@portabletext/editor 1.35.3 → 1.35.4

package/lib/_chunks-es/editor-provider.js

@@ -4,9 +4,9 @@ import React, { createContext, useContext, useEffect, useState, startTransition,
 import { ReactEditor, withReact, Slate } from "slate-react";
 import { useSelector, useActorRef } from "@xstate/react";
 import debug$e from "debug";
-import { Editor, Element, Range, Point, Text, Operation, Transforms, Path, Node, insertText, select, deleteFragment, deleteForward, createEditor as createEditor$1 } from "slate";
-import { setup, emit, assign, fromCallback, assertEvent, enqueueActions, createActor } from "xstate";
 import isEqual from "lodash/isEqual.js";
+import { Editor, Element, Range, Point, Text, Operation, Transforms, Path, Node, insertText, select, deleteFragment, deleteForward, createEditor as createEditor$1 } from "slate";
+import { setup, emit, enqueueActions, assign, assertEvent, fromCallback, stateIn, and, not, createActor } from "xstate";
 import { unset, set, setIfMissing, insert, diffMatchPatch as diffMatchPatch$1, applyAll } from "@portabletext/patches";
 import { defineType, defineField, isKeySegment, isPortableTextTextBlock, isPortableTextSpan as isPortableTextSpan$1, isPortableTextListBlock } from "@sanity/types";
 import flatten from "lodash/flatten.js";
@@ -343,7 +343,7 @@ function compileType(rawType) {
     types: [rawType]
   }).get(rawType.name);
 }
-const FLUSH_PATCHES_THROTTLED_MS = process.env.NODE_ENV === "test" ? 500 : 1e3, mutationMachine = setup({
+const mutationMachine = setup({
   types: {
     context: {},
     events: {},
@@ -354,63 +354,152 @@ const FLUSH_PATCHES_THROTTLED_MS = process.env.NODE_ENV === "test" ? 500 : 1e3,
     "emit has pending patches": emit({
       type: "has pending patches"
     }),
-    "emit mutation": emit(({
-      context
-    }) => ({
-      type: "mutation",
-      patches: context.pendingPatches,
-      snapshot: fromSlateValue(context.slateEditor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(context.slateEditor))
-    })),
-    "clear pending patches": assign({
-      pendingPatches: []
+    "emit mutations": enqueueActions(({
+      context,
+      enqueue
+    }) => {
+      for (const bulk of context.pendingMutations)
+        enqueue.emit({
+          type: "mutation",
+          patches: bulk.patches,
+          snapshot: bulk.value
+        });
+    }),
+    "clear pending mutations": assign({
+      pendingMutations: []
     }),
     "defer patch": assign({
-      pendingPatches: ({
+      pendingMutations: ({
         context,
         event
-      }) => [...context.pendingPatches, event.patch]
+      }) => {
+        if (assertEvent(event, "patch"), context.pendingMutations.length === 0)
+          return [{
+            actionId: event.actionId,
+            value: event.value,
+            patches: [event.patch]
+          }];
+        const lastBulk = context.pendingMutations.at(-1);
+        return lastBulk && lastBulk.actionId === event.actionId ? context.pendingMutations.slice(0, -1).concat({
+          value: event.value,
+          actionId: lastBulk.actionId,
+          patches: [...lastBulk.patches, event.patch]
+        }) : context.pendingMutations.concat({
+          value: event.value,
+          actionId: event.actionId,
+          patches: [event.patch]
+        });
+      }
+    })
+  },
+  actors: {
+    "type listener": fromCallback(({
+      input,
+      sendBack
+    }) => {
+      const originalApply = input.slateEditor.apply;
+      return input.slateEditor.apply = (op) => {
+        op.type === "insert_text" || op.type === "remove_text" ? sendBack({
+          type: "typing"
+        }) : sendBack({
+          type: "not typing"
+        }), originalApply(op);
+      }, () => {
+        input.slateEditor.apply = originalApply;
+      };
     })
   },
   guards: {
+    "is typing": stateIn({
+      typing: "typing"
+    }),
+    "no pending mutations": ({
+      context
+    }) => context.pendingMutations.length === 0,
     "slate is normalizing": ({
       context
     }) => Editor.isNormalizing(context.slateEditor)
+  },
+  delays: {
+    "mutation debounce": process.env.NODE_ENV === "test" ? 250 : 0,
+    "type debounce": process.env.NODE_ENV === "test" ? 0 : 250
   }
 }).createMachine({
   id: "mutation",
   context: ({
     input
   }) => ({
-    pendingPatches: [],
+    pendingMutations: [],
     schema: input.schema,
     slateEditor: input.slateEditor
   }),
-  initial: "idle",
+  type: "parallel",
   states: {
-    idle: {
-      on: {
-        patch: {
-          actions: ["defer patch", "emit has pending patches"],
-          target: "has pending patches"
+    typing: {
+      initial: "idle",
+      invoke: {
+        src: "type listener",
+        input: ({
+          context
+        }) => ({
+          slateEditor: context.slateEditor
+        })
+      },
+      states: {
+        idle: {
+          on: {
+            typing: {
+              target: "typing"
+            }
+          }
+        },
+        typing: {
+          after: {
+            "type debounce": {
+              target: "idle"
+            }
+          },
+          on: {
+            "not typing": {
+              target: "idle"
+            },
+            typing: {
+              target: "typing",
+              reenter: !0
+            }
+          }
         }
       }
     },
-    "has pending patches": {
-      after: {
-        [FLUSH_PATCHES_THROTTLED_MS]: [{
-          guard: "slate is normalizing",
-          target: "idle",
-          actions: ["emit mutation", "clear pending patches"]
-        }, {
-          target: "has pending patches",
-          reenter: !0
-        }]
-      },
-      on: {
-        patch: {
-          target: "has pending patches",
-          actions: ["defer patch"],
-          reenter: !0
+    mutations: {
+      initial: "idle",
+      states: {
+        idle: {
+          on: {
+            patch: {
+              actions: ["defer patch", "emit has pending patches"],
+              target: "emitting mutations"
+            }
+          }
+        },
+        "emitting mutations": {
+          after: {
+            "mutation debounce": [{
+              guard: and([not("is typing"), "slate is normalizing"]),
+              target: "idle",
+              actions: ["emit mutations", "clear pending mutations"]
+            }, {
+              target: "emitting mutations",
+              reenter: !0
+            }]
+          },
+          on: {
+            patch: {
+              target: "emitting mutations",
+              actions: ["defer patch"],
+              reenter: !0
+            }
+          }
         }
       }
     }
@@ -1436,13 +1525,15 @@ function randomKey(length) {
   const table = getByteHexTable();
   return whatwgRNG(length).reduce((str, n) => str + table[n], "").slice(0, length);
 }
-const IS_APPLYING_BEHAVIOR_ACTIONS = /* @__PURE__ */ new WeakMap();
+const CURRENT_ACTION_ID = /* @__PURE__ */ new WeakMap();
 function withApplyingBehaviorActions(editor, fn) {
-  const prev = IS_APPLYING_BEHAVIOR_ACTIONS.get(editor);
-  IS_APPLYING_BEHAVIOR_ACTIONS.set(editor, !0), Editor.withoutNormalizing(editor, fn), IS_APPLYING_BEHAVIOR_ACTIONS.set(editor, prev);
+  CURRENT_ACTION_ID.set(editor, defaultKeyGenerator()), Editor.withoutNormalizing(editor, fn), CURRENT_ACTION_ID.set(editor, void 0);
+}
+function getCurrentActionId(editor) {
+  return CURRENT_ACTION_ID.get(editor);
 }
 function isApplyingBehaviorActions(editor) {
-  return IS_APPLYING_BEHAVIOR_ACTIONS.get(editor) ?? !1;
+  return getCurrentActionId(editor) !== void 0;
 }
 const CURRENT_BEHAVIOR_ACTION_INTEND_SET = /* @__PURE__ */ new WeakMap();
 function withApplyingBehaviorActionIntendSet(editor, fn) {
@@ -2165,7 +2256,7 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
 }
 const debug$b = debugWithName("component:PortableTextEditor:Synchronizer");
 function Synchronizer(props) {
-  const $ = c(40), {
+  const $ = c(41), {
     editorActor,
     slateEditor
   } = props, value = useSelector(props.editorActor, _temp), readOnly = useSelector(props.editorActor, _temp2);
@@ -2217,7 +2308,7 @@ function Synchronizer(props) {
     };
   }, t8 = [mutationActorRef, syncActorRef, editorActor], $[16] = editorActor, $[17] = mutationActorRef, $[18] = syncActorRef, $[19] = t7, $[20] = t8) : (t7 = $[19], t8 = $[20]), useEffect(t7, t8);
   let t10, t9;
-  $[21] !== props.editorActor || $[22] !== syncActorRef ? (t9 = () => {
+  $[21] !== props.editorActor || $[22] !== slateEditor || $[23] !== syncActorRef ? (t9 = () => {
     const subscription_0 = syncActorRef.on("*", (event_0) => {
       bb15: switch (event_0.type) {
         case "invalid value": {
@@ -2234,6 +2325,14 @@ function Synchronizer(props) {
           });
           break bb15;
         }
+        case "patch": {
+          props.editorActor.send({
+            ...event_0,
+            type: "internal.patch",
+            value: fromSlateValue(slateEditor.children, props.editorActor.getSnapshot().context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(slateEditor))
+          });
+          break bb15;
+        }
         default:
           props.editorActor.send(event_0);
       }
@@ -2241,33 +2340,36 @@ function Synchronizer(props) {
     return () => {
       subscription_0.unsubscribe();
     };
-  }, t10 = [props.editorActor, syncActorRef], $[21] = props.editorActor, $[22] = syncActorRef, $[23] = t10, $[24] = t9) : (t10 = $[23], t9 = $[24]), useEffect(t9, t10);
+  }, t10 = [props.editorActor, slateEditor, syncActorRef], $[21] = props.editorActor, $[22] = slateEditor, $[23] = syncActorRef, $[24] = t10, $[25] = t9) : (t10 = $[24], t9 = $[25]), useEffect(t9, t10);
   let t11, t12;
-  $[25] !== readOnly || $[26] !== syncActorRef ? (t11 = () => {
+  $[26] !== readOnly || $[27] !== syncActorRef ? (t11 = () => {
     syncActorRef.send({
       type: "update readOnly",
       readOnly
     });
-  }, t12 = [syncActorRef, readOnly], $[25] = readOnly, $[26] = syncActorRef, $[27] = t11, $[28] = t12) : (t11 = $[27], t12 = $[28]), useEffect(t11, t12);
+  }, t12 = [syncActorRef, readOnly], $[26] = readOnly, $[27] = syncActorRef, $[28] = t11, $[29] = t12) : (t11 = $[28], t12 = $[29]), useEffect(t11, t12);
   let t13, t14;
-  $[29] !== syncActorRef || $[30] !== value ? (t13 = () => {
+  $[30] !== syncActorRef || $[31] !== value ? (t13 = () => {
     debug$b("Value from props changed, syncing new value"), syncActorRef.send({
       type: "update value",
       value
     });
-  }, t14 = [syncActorRef, value], $[29] = syncActorRef, $[30] = value, $[31] = t13, $[32] = t14) : (t13 = $[31], t14 = $[32]), useEffect(t13, t14);
+  }, t14 = [syncActorRef, value], $[30] = syncActorRef, $[31] = value, $[32] = t13, $[33] = t14) : (t13 = $[32], t14 = $[33]), useEffect(t13, t14);
   let t15;
-  $[33] !== editorActor || $[34] !== mutationActorRef ? (t15 = () => {
+  $[34] !== editorActor || $[35] !== mutationActorRef ? (t15 = () => {
     debug$b("Subscribing to patch events");
-    const sub = editorActor.on("patch", (event_1) => {
-      mutationActorRef.send(event_1);
+    const sub = editorActor.on("internal.patch", (event_1) => {
+      mutationActorRef.send({
+        ...event_1,
+        type: "patch"
+      });
     });
     return () => {
       debug$b("Unsubscribing to patch events"), sub.unsubscribe();
     };
-  }, $[33] = editorActor, $[34] = mutationActorRef, $[35] = t15) : t15 = $[35];
+  }, $[34] = editorActor, $[35] = mutationActorRef, $[36] = t15) : t15 = $[36];
   let t16;
-  return $[36] !== editorActor || $[37] !== mutationActorRef || $[38] !== slateEditor ? (t16 = [editorActor, mutationActorRef, slateEditor], $[36] = editorActor, $[37] = mutationActorRef, $[38] = slateEditor, $[39] = t16) : t16 = $[39], useEffect(t15, t16), null;
+  return $[37] !== editorActor || $[38] !== mutationActorRef || $[39] !== slateEditor ? (t16 = [editorActor, mutationActorRef, slateEditor], $[37] = editorActor, $[38] = mutationActorRef, $[39] = slateEditor, $[40] = t16) : t16 = $[40], useEffect(t15, t16), null;
 }
 function _temp2(s_0) {
   return s_0.matches({
@@ -4868,6 +4970,7 @@ function createWithEventListeners(editorActor, subscriptions) {
           case "loading":
           case "mutation":
           case "patch":
+          case "internal.patch":
           case "patches":
           case "read only":
           case "ready":
@@ -5510,18 +5613,21 @@ function createWithPatches({
           patches = [...patches, ...patchFunctions.moveNodePatch(editor, operation, previousChildren)];
           break;
       }
-      return !editorWasEmpty && editorIsEmpty && ["merge_node", "set_node", "remove_text", "remove_node"].includes(operation.type) && (patches = [...patches, unset([])], editorActor.send({
+      if (!editorWasEmpty && editorIsEmpty && ["merge_node", "set_node", "remove_text", "remove_node"].includes(operation.type) && (patches = [...patches, unset([])], editorActor.send({
         type: "notify.unset",
         previousValue: fromSlateValue(previousChildren, schemaTypes.block.name, KEY_TO_VALUE_ELEMENT.get(editor))
-      })), editorWasEmpty && patches.length > 0 && (patches = [setIfMissing([], []), ...patches]), patches.length > 0 && patches.forEach((patch) => {
-        editorActor.send({
-          type: "patch",
-          patch: {
-            ...patch,
-            origin: "local"
-          }
-        });
-      }), editor;
+      })), editorWasEmpty && patches.length > 0 && (patches = [setIfMissing([], []), ...patches]), patches.length > 0)
+        for (const patch of patches)
+          editorActor.send({
+            type: "internal.patch",
+            patch: {
+              ...patch,
+              origin: "local"
+            },
+            actionId: getCurrentActionId(editor),
+            value: fromSlateValue(editor.children, schemaTypes.block.name, KEY_TO_VALUE_ELEMENT.get(editor))
+          });
+      return editor;
     }, editor;
   };
 }
@@ -5978,9 +6084,15 @@ const editorMachine = setup({
         event
       }) => (assertEvent(event, "update schema"), event.schema)
     }),
-    "emit patch event": emit(({
-      event
-    }) => (assertEvent(event, "patch"), event)),
+    "emit patch event": enqueueActions(({
+      event,
+      enqueue
+    }) => {
+      assertEvent(event, "internal.patch"), enqueue.emit(event), enqueue.emit({
+        type: "patch",
+        patch: event.patch
+      });
+    }),
     "emit mutation event": emit(({
       event
     }) => (assertEvent(event, "mutation"), event)),
@@ -5994,14 +6106,17 @@ const editorMachine = setup({
       pendingEvents: ({
         context,
         event
-      }) => (assertEvent(event, ["patch", "mutation"]), [...context.pendingEvents, event])
+      }) => (assertEvent(event, ["internal.patch", "mutation"]), [...context.pendingEvents, event])
     }),
     "emit pending events": enqueueActions(({
       context,
       enqueue
     }) => {
       for (const event of context.pendingEvents)
-        enqueue(emit(event));
+        event.type === "internal.patch" ? (enqueue.emit(event), enqueue.emit({
+          type: "patch",
+          patch: event.patch
+        })) : enqueue.emit(event);
     }),
     "emit ready": emit({
       type: "ready"
@@ -6417,7 +6532,7 @@ const editorMachine = setup({
         "setting up": {
           exit: ["emit ready"],
           on: {
-            patch: {
+            "internal.patch": {
               actions: "defer event"
             },
             mutation: {
@@ -6436,7 +6551,7 @@ const editorMachine = setup({
                 normalizing: {
                   target: "normalizing"
                 },
-                patch: {
+                "internal.patch": {
                   actions: "defer event",
                   target: "#editor.setup.dirty"
                 },
@@ -6451,7 +6566,7 @@ const editorMachine = setup({
                 "done normalizing": {
                   target: "idle"
                 },
-                patch: {
+                "internal.patch": {
                   actions: "defer event"
                 },
                 mutation: {
@@ -6464,7 +6579,7 @@ const editorMachine = setup({
         dirty: {
           entry: ["emit pending events", "clear pending events"],
           on: {
-            patch: {
+            "internal.patch": {
               actions: "emit patch event"
             },
             mutation: {