@portabletext/editor 2.8.3 → 2.8.4

package/lib/index.cjs

@@ -3669,19 +3669,17 @@ function toInt(num) {
   return parseInt(num, 10);
 }
 const CURRENT_UNDO_STEP = /* @__PURE__ */ new WeakMap();
-function withUndoStep(editor, fn) {
-  const current = CURRENT_UNDO_STEP.get(editor);
-  if (current) {
-    fn();
-    return;
-  }
-  CURRENT_UNDO_STEP.set(editor, current ?? {
-    undoStepId: util_sliceBlocks.defaultKeyGenerator()
-  }), fn(), CURRENT_UNDO_STEP.set(editor, void 0);
-}
 function getCurrentUndoStepId(editor) {
   return CURRENT_UNDO_STEP.get(editor)?.undoStepId;
 }
+function createUndoStep(editor) {
+  CURRENT_UNDO_STEP.set(editor, {
+    undoStepId: util_sliceBlocks.defaultKeyGenerator()
+  });
+}
+function clearUndoStep(editor) {
+  CURRENT_UNDO_STEP.set(editor, void 0);
+}
 const debug$b = debugWithName("plugin:withUndoRedo"), SAVING = /* @__PURE__ */ new WeakMap(), REMOTE_PATCHES = /* @__PURE__ */ new WeakMap(), UNDO_STEP_LIMIT = 1e3, isSaving = (editor) => {
   const state = SAVING.get(editor);
   return state === void 0 ? !0 : state;
@@ -9027,7 +9025,7 @@ function performEvent({
   nativeEvent,
   sendBack
 }) {
-  debug$6(`(${mode}:${eventCategory(event)})`, JSON.stringify(event, null, 2));
+  mode === "send" && !isNativeBehaviorEvent(event) && createUndoStep(editor), debug$6(`(${mode}:${eventCategory(event)})`, JSON.stringify(event, null, 2));
   const eventBehaviors = [...remainingEventBehaviors, ...abstractBehaviors].filter((behavior) => {
     if (behavior.on === "*")
       return !0;
@@ -9035,7 +9033,7 @@ function performEvent({
     return listenedNamespace !== void 0 && eventNamespace !== void 0 && listenedNamespace === eventNamespace || listenedNamespace !== void 0 && eventNamespace === void 0 && listenedNamespace === event.type ? !0 : behavior.on === event.type;
   });
   if (eventBehaviors.length === 0 && isSyntheticBehaviorEvent(event)) {
-    nativeEvent?.preventDefault(), withApplyingBehaviorOperations(editor, () => {
+    nativeEvent?.preventDefault(), mode === "send" && clearUndoStep(editor), withApplyingBehaviorOperations(editor, () => {
       debug$6(`(execute:${eventCategory(event)})`, JSON.stringify(event, null, 2)), performOperation({
         context: {
           keyGenerator,
@@ -9079,63 +9077,63 @@ function performEvent({
         }
         if (actions.length !== 0) {
           if (nativeEventPrevented = actions.some((action) => action.type === "raise" || action.type === "execute") || !actions.some((action) => action.type === "forward"), actions.some((action) => action.type === "execute")) {
-            withUndoStep(editor, () => {
-              for (const action of actions) {
-                if (action.type === "effect") {
-                  try {
-                    action.effect({
-                      send: sendBack
-                    });
-                  } catch (error) {
-                    console.error(new Error(`Executing effect as a result of "${event.type}" failed due to: ${error.message}`));
-                  }
-                  continue;
-                }
-                if (action.type === "forward") {
-                  const remainingEventBehaviors2 = eventBehaviors.slice(eventBehaviorIndex + 1);
-                  performEvent({
-                    mode: "forward",
-                    behaviors,
-                    remainingEventBehaviors: remainingEventBehaviors2,
-                    event: action.event,
-                    editor,
-                    keyGenerator,
-                    schema: schema2,
-                    getSnapshot,
-                    nativeEvent,
-                    sendBack
-                  });
-                  continue;
-                }
-                if (action.type === "raise") {
-                  performEvent({
-                    mode: "raise",
-                    behaviors,
-                    remainingEventBehaviors: behaviors,
-                    event: action.event,
-                    editor,
-                    keyGenerator,
-                    schema: schema2,
-                    getSnapshot,
-                    nativeEvent,
-                    sendBack
+            createUndoStep(editor);
+            for (const action of actions) {
+              if (action.type === "effect") {
+                try {
+                  action.effect({
+                    send: sendBack
                   });
-                  continue;
+                } catch (error) {
+                  console.error(new Error(`Executing effect as a result of "${event.type}" failed due to: ${error.message}`));
                 }
+                continue;
+              }
+              if (action.type === "forward") {
+                const remainingEventBehaviors2 = eventBehaviors.slice(eventBehaviorIndex + 1);
                 performEvent({
-                  mode: "execute",
+                  mode: "forward",
                   behaviors,
-                  remainingEventBehaviors: [],
+                  remainingEventBehaviors: remainingEventBehaviors2,
                   event: action.event,
                   editor,
                   keyGenerator,
                   schema: schema2,
                   getSnapshot,
-                  nativeEvent: void 0,
+                  nativeEvent,
                   sendBack
                 });
+                continue;
               }
-            });
+              if (action.type === "raise") {
+                performEvent({
+                  mode: "raise",
+                  behaviors,
+                  remainingEventBehaviors: behaviors,
+                  event: action.event,
+                  editor,
+                  keyGenerator,
+                  schema: schema2,
+                  getSnapshot,
+                  nativeEvent,
+                  sendBack
+                });
+                continue;
+              }
+              performEvent({
+                mode: "execute",
+                behaviors,
+                remainingEventBehaviors: [],
+                event: action.event,
+                editor,
+                keyGenerator,
+                schema: schema2,
+                getSnapshot,
+                nativeEvent: void 0,
+                sendBack
+              });
+            }
+            clearUndoStep(editor);
             continue;
           }
           for (const action of actions) {
@@ -9187,7 +9185,7 @@ function performEvent({
       break;
     }
   }
-  !defaultBehaviorOverwritten && isSyntheticBehaviorEvent(event) ? (nativeEvent?.preventDefault(), withApplyingBehaviorOperations(editor, () => {
+  !defaultBehaviorOverwritten && isSyntheticBehaviorEvent(event) ? (nativeEvent?.preventDefault(), mode === "send" && clearUndoStep(editor), withApplyingBehaviorOperations(editor, () => {
     debug$6(`(execute:${eventCategory(event)})`, JSON.stringify(event, null, 2)), performOperation({
       context: {
         keyGenerator,
@@ -9268,7 +9266,44 @@ function createEditorSnapshot({
     decoratorState: editor.decoratorState
   };
 }
-const debug$5 = debugWithName("editor machine"), editorMachine = xstate.setup({
+const debug$5 = debugWithName("editor machine");
+function rerouteExternalBehaviorEvent({
+  event,
+  slateEditor
+}) {
+  switch (event.type) {
+    case "blur":
+      return {
+        type: "blur",
+        editor: slateEditor
+      };
+    case "focus":
+      return {
+        type: "focus",
+        editor: slateEditor
+      };
+    case "insert.block object":
+      return {
+        type: "behavior event",
+        behaviorEvent: {
+          type: "insert.block",
+          block: {
+            _type: event.blockObject.name,
+            ...event.blockObject.value ?? {}
+          },
+          placement: event.placement
+        },
+        editor: slateEditor
+      };
+    default:
+      return {
+        type: "behavior event",
+        behaviorEvent: event,
+        editor: slateEditor
+      };
+  }
+}
+const editorMachine = xstate.setup({
   types: {
     context: {},
     events: {},
@@ -9370,7 +9405,7 @@ const debug$5 = debugWithName("editor machine"), editorMachine = xstate.setup({
       try {
         const behaviors = [...context.behaviors.values()].map((config) => config.behavior);
         performEvent({
-          mode: "raise",
+          mode: "send",
           behaviors,
           remainingEventBehaviors: behaviors,
           event: event.behaviorEvent,
@@ -9392,11 +9427,10 @@ const debug$5 = debugWithName("editor machine"), editorMachine = xstate.setup({
               self.send(eventSentBack);
               return;
             }
-            self.send({
-              type: "behavior event",
-              behaviorEvent: eventSentBack,
-              editor: event.editor
-            });
+            self.send(rerouteExternalBehaviorEvent({
+              event: eventSentBack,
+              slateEditor: event.editor
+            }));
           }
         });
       } catch (error) {
@@ -11342,38 +11376,11 @@ function createInternalEditor(config) {
         case "update maxBlocks":
           editorActor.send(event);
           break;
-        case "blur":
-          editorActor.send({
-            type: "blur",
-            editor: slateEditor.instance
-          });
-          break;
-        case "focus":
-          editorActor.send({
-            type: "focus",
-            editor: slateEditor.instance
-          });
-          break;
-        case "insert.block object":
-          editorActor.send({
-            type: "behavior event",
-            behaviorEvent: {
-              type: "insert.block",
-              block: {
-                _type: event.blockObject.name,
-                ...event.blockObject.value ?? {}
-              },
-              placement: event.placement
-            },
-            editor: slateEditor.instance
-          });
-          break;
         default:
-          editorActor.send({
-            type: "behavior event",
-            behaviorEvent: event,
-            editor: slateEditor.instance
-          });
+          editorActor.send(rerouteExternalBehaviorEvent({
+            event,
+            slateEditor: slateEditor.instance
+          }));
       }
     },
     on: (event, listener) => relayActor.on(event, (event2) => {