@portabletext/editor 1.47.14 → 1.48.0

package/lib/_chunks-cjs/editor-provider.cjs

@@ -1309,19 +1309,19 @@ function getCurrentActionId(editor) {
 function isApplyingBehaviorActions(editor) {
   return getCurrentActionId(editor) !== void 0;
 }
-const CURRENT_BEHAVIOR_ACTION_SET = /* @__PURE__ */ new WeakMap();
-function withApplyingBehaviorActionSet(editor, fn) {
-  const current = CURRENT_BEHAVIOR_ACTION_SET.get(editor);
+const CURRENT_UNDO_STEP = /* @__PURE__ */ new WeakMap();
+function withUndoStep(editor, fn) {
+  const current = CURRENT_UNDO_STEP.get(editor);
   if (current) {
     fn();
     return;
   }
-  CURRENT_BEHAVIOR_ACTION_SET.set(editor, current ?? {
-    actionSetId: defaultKeyGenerator()
-  }), fn(), CURRENT_BEHAVIOR_ACTION_SET.set(editor, void 0);
+  CURRENT_UNDO_STEP.set(editor, current ?? {
+    undoStepId: defaultKeyGenerator()
+  }), fn(), CURRENT_UNDO_STEP.set(editor, void 0);
 }
-function getCurrentBehaviorActionSetId(editor) {
-  return CURRENT_BEHAVIOR_ACTION_SET.get(editor)?.actionSetId;
+function getCurrentUndoStepId(editor) {
+  return CURRENT_UNDO_STEP.get(editor)?.undoStepId;
 }
 const debug$f = debugWithName("plugin:withUndoRedo"), SAVING = /* @__PURE__ */ new WeakMap(), REMOTE_PATCHES = /* @__PURE__ */ new WeakMap(), UNDO_STEP_LIMIT = 1e3, isSaving = (editor) => {
   const state = SAVING.get(editor);
@@ -1334,7 +1334,7 @@ function createWithUndoRedo(options) {
   return (editor) => {
     let previousSnapshot = fromSlateValue(editor.children, editorActor.getSnapshot().context.schema.block.name);
     const remotePatches = getRemotePatches(editor);
-    let previousBehaviorActionSetId = getCurrentBehaviorActionSetId(editor);
+    let previousUndoStepId = getCurrentUndoStepId(editor);
     options.subscriptions.push(() => {
       debug$f("Subscribing to patches");
       const sub = editorActor.on("patches", ({
@@ -1390,10 +1390,10 @@ function createWithUndoRedo(options) {
         history
       } = editor, {
         undos
-      } = history, step = undos[undos.length - 1], lastOp = step && step.operations && step.operations[step.operations.length - 1], overwrite = shouldOverwrite(op, lastOp), save = isSaving(editor), currentBehaviorActionSetId = getCurrentBehaviorActionSetId(editor);
-      let merge = currentBehaviorActionSetId !== void 0 && previousBehaviorActionSetId === void 0 ? !1 : currentBehaviorActionSetId !== void 0 && previousBehaviorActionSetId !== void 0 ? currentBehaviorActionSetId === previousBehaviorActionSetId : !0;
+      } = history, step = undos[undos.length - 1], lastOp = step && step.operations && step.operations[step.operations.length - 1], overwrite = shouldOverwrite(op, lastOp), save = isSaving(editor), currentUndoStepId = getCurrentUndoStepId(editor);
+      let merge = currentUndoStepId !== void 0 && previousUndoStepId === void 0 ? !1 : currentUndoStepId !== void 0 && previousUndoStepId !== void 0 ? currentUndoStepId === previousUndoStepId : !0;
       if (save) {
-        if (step ? operations.length === 0 && (merge = currentBehaviorActionSetId === void 0 && previousBehaviorActionSetId === void 0 ? shouldMerge(op, lastOp) || overwrite : merge) : merge = !1, step && merge)
+        if (step ? operations.length === 0 && (merge = currentUndoStepId === void 0 && previousUndoStepId === void 0 ? shouldMerge(op, lastOp) || overwrite : merge) : merge = !1, step && merge)
           step.operations.push(op);
         else {
           const newStep = {
@@ -1406,7 +1406,7 @@ function createWithUndoRedo(options) {
           undos.shift();
         shouldClear(op) && (history.redos = []);
       }
-      previousBehaviorActionSetId = currentBehaviorActionSetId, apply2(op);
+      previousUndoStepId = currentUndoStepId, apply2(op);
     }, editor;
   };
 }
@@ -4010,7 +4010,6 @@ const moveBackwardActionImplementation = ({
     unit: "character",
     distance: action.distance
   });
-}, noopActionImplementation = () => {
 }, selectActionImplementation = ({
   action
 }) => {
@@ -4037,7 +4036,6 @@ const moveBackwardActionImplementation = ({
   "move.backward": moveBackwardActionImplementation,
   "move.block": moveBlockActionImplementation,
   "move.forward": moveForwardActionImplementation,
-  noop: noopActionImplementation,
   select: selectActionImplementation
 };
 function performAction({
@@ -4185,8 +4183,6 @@ function performAction({
       });
       break;
     }
-    case "noop":
-      break;
     default: {
       behaviorActionImplementations.select({
         context,
@@ -5771,7 +5767,20 @@ function createInternalEditor(editorActor) {
     }
   };
 }
-const EditorActorContext = React.createContext({}), abstractAnnotationBehaviors = [behavior_core.defineBehavior({
+const EditorActorContext = React.createContext({});
+function getGlobalScope() {
+  if (typeof globalThis < "u") return globalThis;
+  if (typeof window < "u") return window;
+  if (typeof self < "u") return self;
+  if (typeof global < "u") return global;
+  throw new Error("@portabletext/editor: could not locate global scope");
+}
+const globalScope = getGlobalScope();
+function createGloballyScopedContext(key, defaultValue) {
+  const symbol = Symbol.for(key);
+  return typeof document > "u" ? React.createContext(defaultValue) : (globalScope[symbol] = globalScope[symbol] ?? React.createContext(defaultValue), globalScope[symbol]);
+}
+const EditorContext = createGloballyScopedContext("@portabletext/editor/context/editor", null), abstractAnnotationBehaviors = [behavior_core.defineBehavior({
   on: "annotation.toggle",
   guard: ({
     snapshot,
@@ -6353,9 +6362,7 @@ const EditorActorContext = React.createContext({}), abstractAnnotationBehaviors
       const focusSpan = selector_isOverlappingSelection.getFocusSpan(snapshot), selectionCollapsed = selector_isOverlappingSelection.isSelectionCollapsed(snapshot);
       return focusSpan && selectionCollapsed;
     },
-    actions: [() => [{
-      type: "noop"
-    }]]
+    actions: []
   }),
   behavior_core.defineBehavior({
     on: "clipboard.copy",
@@ -6374,9 +6381,7 @@ const EditorActorContext = React.createContext({}), abstractAnnotationBehaviors
       const focusSpan = selector_isOverlappingSelection.getFocusSpan(snapshot), selectionCollapsed = selector_isOverlappingSelection.isSelectionCollapsed(snapshot);
       return focusSpan && selectionCollapsed;
     },
-    actions: [() => [{
-      type: "noop"
-    }]]
+    actions: []
   }),
   behavior_core.defineBehavior({
     on: "clipboard.cut",
@@ -6443,9 +6448,7 @@ const EditorActorContext = React.createContext({}), abstractAnnotationBehaviors
         }
       }) : !1;
     },
-    actions: [() => [{
-      type: "noop"
-    }]]
+    actions: []
   }),
   behavior_core.defineBehavior({
     on: "drag.drop",
@@ -6651,6 +6654,7 @@ function eventCategory(event) {
 function performEvent({
   mode,
   behaviors,
+  remainingEventBehaviors,
   event,
   editor,
   keyGenerator,
@@ -6658,11 +6662,11 @@ function performEvent({
   getSnapshot,
   nativeEvent
 }) {
-  debug$2(`(${isNativeBehaviorEvent(event) ? "" : `${mode}:`}${eventCategory(event)})`, JSON.stringify(event, null, 2));
+  debug$2(`(${mode}:${eventCategory(event)})`, JSON.stringify(event, null, 2));
   const defaultAction = isCustomBehaviorEvent(event) || isNativeBehaviorEvent(event) || isAbstractBehaviorEvent(event) ? void 0 : {
     ...event,
     editor
-  }, eventBehaviors = (mode === "raise" ? [...behaviors, ...defaultBehaviors] : behaviors).filter((behavior) => {
+  }, eventBehaviors = [...remainingEventBehaviors, ...defaultBehaviors].filter((behavior) => {
     if (behavior.on === "*")
       return !0;
     const [listenedNamespace] = behavior.on.includes("*") && behavior.on.includes(".") ? behavior.on.split(".") : [void 0], [eventNamespace] = event.type.includes(".") ? event.type.split(".") : [void 0];
@@ -6687,115 +6691,167 @@ function performEvent({
     return;
   }
   const guardSnapshot = getSnapshot();
-  let behaviorOverwritten = !1;
+  let nativeEventPrevented = !1, defaultBehaviorOverwritten = !1, eventBehaviorIndex = -1;
   for (const eventBehavior of eventBehaviors) {
+    eventBehaviorIndex++;
     const shouldRun = eventBehavior.guard === void 0 || eventBehavior.guard({
       snapshot: guardSnapshot,
       event
     });
     if (shouldRun) {
+      defaultBehaviorOverwritten = !0;
       for (const actionSet of eventBehavior.actions) {
         const actionsSnapshot = getSnapshot(), actions = actionSet({
           snapshot: actionsSnapshot,
           event
         }, shouldRun);
-        actions.length !== 0 && (behaviorOverwritten = behaviorOverwritten || actions.some((action) => action.type !== "effect"), withApplyingBehaviorActionSet(editor, () => {
+        if (actions.length !== 0) {
+          if (actions.some((action) => action.type === "execute")) {
+            nativeEventPrevented = !0, withUndoStep(editor, () => {
+              for (const action of actions) {
+                if (action.type === "effect") {
+                  performAction({
+                    context: {
+                      keyGenerator,
+                      schema: schema2
+                    },
+                    action: {
+                      ...action,
+                      editor
+                    }
+                  });
+                  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
+                  });
+                  continue;
+                }
+                if (action.type === "raise") {
+                  performEvent({
+                    mode: "raise",
+                    behaviors,
+                    remainingEventBehaviors: behaviors,
+                    event: action.event,
+                    editor,
+                    keyGenerator,
+                    schema: schema2,
+                    getSnapshot,
+                    nativeEvent
+                  });
+                  continue;
+                }
+                if (isAbstractBehaviorEvent(action.event))
+                  performEvent({
+                    mode: "execute",
+                    behaviors,
+                    remainingEventBehaviors: behaviors,
+                    event: action.event,
+                    editor,
+                    keyGenerator,
+                    schema: schema2,
+                    getSnapshot,
+                    nativeEvent: void 0
+                  });
+                else {
+                  const internalAction = {
+                    ...action.event,
+                    editor
+                  };
+                  let actionFailed = !1;
+                  if (withApplyingBehaviorActions(editor, () => {
+                    try {
+                      performAction({
+                        context: {
+                          keyGenerator,
+                          schema: schema2
+                        },
+                        action: internalAction
+                      });
+                    } catch (error) {
+                      console.error(new Error(`Performing action "${action.event.type}" as a result of "${event.type}" failed due to: ${error.message}`)), actionFailed = !0;
+                    }
+                  }), actionFailed)
+                    break;
+                  editor.onChange();
+                }
+              }
+            });
+            continue;
+          }
           for (const action of actions) {
-            if (action.type === "raise") {
+            if (action.type === "effect") {
+              performAction({
+                context: {
+                  keyGenerator,
+                  schema: schema2
+                },
+                action: {
+                  ...action,
+                  editor
+                }
+              });
+              continue;
+            }
+            if (action.type === "forward") {
+              const remainingEventBehaviors2 = eventBehaviors.slice(eventBehaviorIndex + 1);
               performEvent({
-                mode,
-                behaviors: mode === "execute" ? isCustomBehaviorEvent(action.event) ? [...behaviors, ...defaultBehaviors] : defaultBehaviors : [...behaviors, ...defaultBehaviors],
+                mode: "forward",
+                behaviors,
+                remainingEventBehaviors: remainingEventBehaviors2,
                 event: action.event,
                 editor,
                 keyGenerator,
                 schema: schema2,
                 getSnapshot,
-                nativeEvent: void 0
+                nativeEvent
               });
               continue;
             }
-            if (action.type === "execute") {
-              if (isAbstractBehaviorEvent(action.event))
-                performEvent({
-                  mode: "execute",
-                  behaviors: defaultBehaviors,
-                  event: action.event,
-                  editor,
-                  keyGenerator,
-                  schema: schema2,
-                  getSnapshot,
-                  nativeEvent: void 0
-                });
-              else {
-                const internalAction2 = {
-                  ...action.event,
-                  editor
-                };
-                let actionFailed2 = !1;
-                if (withApplyingBehaviorActions(editor, () => {
-                  try {
-                    performAction({
-                      context: {
-                        keyGenerator,
-                        schema: schema2
-                      },
-                      action: internalAction2
-                    });
-                  } catch (error) {
-                    console.error(new Error(`Performing action "${action.event.type}" as a result of "${event.type}" failed due to: ${error.message}`)), actionFailed2 = !0;
-                  }
-                }), actionFailed2)
-                  break;
-                editor.onChange();
-              }
+            if (action.type === "raise") {
+              nativeEventPrevented = !0, performEvent({
+                mode: "raise",
+                behaviors,
+                remainingEventBehaviors: behaviors,
+                event: action.event,
+                editor,
+                keyGenerator,
+                schema: schema2,
+                getSnapshot,
+                nativeEvent
+              });
               continue;
             }
-            const internalAction = {
-              ...action,
-              editor
-            };
-            let actionFailed = !1;
-            if (withApplyingBehaviorActions(editor, () => {
-              try {
-                performAction({
-                  context: {
-                    keyGenerator,
-                    schema: schema2
-                  },
-                  action: internalAction
-                });
-              } catch (error) {
-                console.error(new Error(`Performing action "${internalAction.type}" as a result of "${event.type}" failed due to: ${error.message}`)), actionFailed = !0;
-              }
-            }), actionFailed)
-              break;
-            editor.onChange();
+            action.type === "execute" && console.error("Unexpected action type: `execute`");
           }
-        }));
-      }
-      if (behaviorOverwritten) {
-        nativeEvent?.preventDefault();
-        break;
+        }
       }
+      break;
     }
   }
-  if (!behaviorOverwritten) {
-    if (!defaultAction)
-      return;
-    withApplyingBehaviorActions(editor, () => {
-      try {
-        performAction({
-          context: {
-            keyGenerator,
-            schema: schema2
-          },
-          action: defaultAction
-        });
-      } catch (error) {
-        console.error(new Error(`Performing action "${defaultAction.type}" as a result of "${event.type}" failed due to: ${error.message}`));
-      }
-    }), editor.onChange();
-  }
+  !defaultBehaviorOverwritten && defaultAction ? (nativeEvent?.preventDefault(), withApplyingBehaviorActions(editor, () => {
+    try {
+      performAction({
+        context: {
+          keyGenerator,
+          schema: schema2
+        },
+        action: defaultAction
+      });
+    } catch (error) {
+      console.error(new Error(`Performing action "${defaultAction.type}" as a result of "${event.type}" failed due to: ${error.message}`));
+    }
+  }), editor.onChange()) : nativeEventPrevented && nativeEvent?.preventDefault();
 }
 function createEditorSnapshot({
   converters,
@@ -6928,11 +6984,12 @@ const editorMachine = xstate.setup({
     "handle behavior event": ({
       context,
       event,
-      self
+      self: self2
     }) => {
       xstate.assertEvent(event, ["behavior event"]), performEvent({
         mode: "raise",
         behaviors: [...context.behaviors.values()],
+        remainingEventBehaviors: [...context.behaviors.values()],
         event: event.behaviorEvent,
         editor: event.editor,
         keyGenerator: context.keyGenerator,
@@ -6941,11 +6998,11 @@ const editorMachine = xstate.setup({
           converters: [...context.converters],
           editor: event.editor,
           keyGenerator: context.keyGenerator,
-          readOnly: self.getSnapshot().matches({
+          readOnly: self2.getSnapshot().matches({
             "edit mode": "read only"
           }),
           schema: context.schema,
-          hasTag: (tag) => self.getSnapshot().hasTag(tag),
+          hasTag: (tag) => self2.getSnapshot().hasTag(tag),
           internalDrag: context.internalDrag
         }),
         nativeEvent: event.nativeEvent
@@ -7822,7 +7879,6 @@ function RouteEventsToChanges(props) {
   let t2;
   return $[5] !== props.editorActor ? (t2 = [props.editorActor], $[5] = props.editorActor, $[6] = t2) : t2 = $[6], React.useEffect(t1, t2), null;
 }
-const EditorContext = React__default.default.createContext(void 0);
 function EditorProvider(props) {
   const editorActor = react.useActorRef(editorMachine, {
     input: editorConfigToMachineInput(props.initialConfig)