@portabletext/editor 2.12.0 → 2.12.2

package/lib/index.js

@@ -8716,7 +8716,15 @@ const abstractAnnotationBehaviors = [defineBehavior({
       marks: [...event.decorators ?? [], ...markDefs.map((markDef) => markDef._key)]
     }
   })]]
-})], abstractKeyboardBehaviors = [
+})], shiftLeft = createKeyboardShortcut({
+  default: [{
+    key: "ArrowLeft",
+    shift: !0,
+    meta: !1,
+    ctrl: !1,
+    alt: !1
+  }]
+}), abstractKeyboardBehaviors = [
   /**
    * Allow raising an `insert.break` event when pressing Enter on an inline
    * object.
@@ -8731,6 +8739,20 @@ const abstractAnnotationBehaviors = [defineBehavior({
       type: "insert.break"
     })]]
   }),
+  /**
+   * On Firefox, Enter might collapse the selection. To mitigate this, we
+   * `raise` an `insert.break` event manually.
+   */
+  defineBehavior({
+    on: "keyboard.keydown",
+    guard: ({
+      snapshot,
+      event
+    }) => defaultKeyboardShortcuts.break.guard(event.originEvent) && isSelectionExpanded(snapshot),
+    actions: [() => [raise({
+      type: "insert.break"
+    })]]
+  }),
   /**
    * On WebKit, Shift+Enter results in an `insertParagraph` input event rather
    * than an `insertLineBreak` input event. This Behavior makes sure we catch
@@ -8768,6 +8790,58 @@ const abstractAnnotationBehaviors = [defineBehavior({
     actions: [() => [raise({
       type: "history.redo"
     })]]
+  }),
+  /**
+   * Fix edge case where Shift+ArrowLeft didn't reduce a selection hanging
+   * onto an empty text block.
+   */
+  defineBehavior({
+    on: "keyboard.keydown",
+    guard: ({
+      snapshot,
+      event
+    }) => {
+      if (!snapshot.context.selection || !shiftLeft.guard(event.originEvent))
+        return !1;
+      const focusBlock = getFocusBlock$1(snapshot);
+      if (!focusBlock)
+        return !1;
+      const previousBlock = getPreviousBlock({
+        ...snapshot,
+        context: {
+          ...snapshot.context,
+          selection: {
+            anchor: {
+              path: focusBlock.path,
+              offset: 0
+            },
+            focus: {
+              path: focusBlock.path,
+              offset: 0
+            }
+          }
+        }
+      });
+      return previousBlock && isTextBlock(snapshot.context, focusBlock.node) && snapshot.context.selection.focus.offset === 0 && isEmptyTextBlock(snapshot.context, focusBlock.node) ? {
+        previousBlock,
+        selection: snapshot.context.selection
+      } : !1;
+    },
+    actions: [({
+      snapshot
+    }, {
+      previousBlock,
+      selection
+    }) => [raise({
+      type: "select",
+      at: {
+        anchor: selection.anchor,
+        focus: getBlockEndPoint({
+          context: snapshot.context,
+          block: previousBlock
+        })
+      }
+    })]]
   })
 ], abstractListItemBehaviors = [defineBehavior({
   on: "list item.add",
@@ -9428,86 +9502,88 @@ function performEvent({
     } catch (error) {
       console.error(new Error(`Evaluating guard for "${event.type}" failed due to: ${error.message}`));
     }
-    if (shouldRun) {
-      defaultBehaviorOverwritten = !0;
-      for (const actionSet of eventBehavior.actions) {
-        const actionsSnapshot = getSnapshot();
-        let actions = [];
-        try {
-          actions = actionSet({
-            snapshot: actionsSnapshot,
-            event,
-            dom: createEditorDom(sendBack, editor)
-          }, shouldRun);
-        } catch (error) {
-          console.error(new Error(`Evaluating actions for "${event.type}" failed due to: ${error.message}`));
-        }
-        if (actions.length === 0)
-          continue;
-        nativeEventPrevented = actions.some((action) => action.type === "raise" || action.type === "execute") || !actions.some((action) => action.type === "forward");
-        let undoStepCreated = !1;
-        actions.some((action) => action.type === "execute") && (createUndoStep(editor), undoStepCreated = !0);
-        const actionTypes = actions.map((action) => action.type), uniqueActionTypes = new Set(actionTypes), raiseGroup = actionTypes.length > 1 && uniqueActionTypes.size === 1 && uniqueActionTypes.has("raise"), executeGroup = actionTypes.length > 1 && uniqueActionTypes.size === 1 && uniqueActionTypes.has("execute");
-        withoutNormalizingConditional(editor, () => raiseGroup || executeGroup, () => {
-          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: mode === "execute" ? "execute" : "forward",
-                behaviors,
-                remainingEventBehaviors: remainingEventBehaviors2,
-                event: action.event,
-                editor,
-                keyGenerator,
-                schema,
-                getSnapshot,
-                nativeEvent,
-                sendBack
-              });
-              continue;
-            }
-            if (action.type === "raise") {
-              performEvent({
-                mode: mode === "execute" ? "execute" : "raise",
-                behaviors,
-                remainingEventBehaviors: mode === "execute" ? remainingEventBehaviors : behaviors,
-                event: action.event,
-                editor,
-                keyGenerator,
-                schema,
-                getSnapshot,
-                nativeEvent,
-                sendBack
+    if (!shouldRun)
+      continue;
+    defaultBehaviorOverwritten = !0, eventBehavior.actions.length === 0 && (nativeEventPrevented = !0);
+    let actionSetIndex = -1;
+    for (const actionSet of eventBehavior.actions) {
+      actionSetIndex++;
+      const actionsSnapshot = getSnapshot();
+      let actions = [];
+      try {
+        actions = actionSet({
+          snapshot: actionsSnapshot,
+          event,
+          dom: createEditorDom(sendBack, editor)
+        }, shouldRun);
+      } catch (error) {
+        console.error(new Error(`Evaluating actions for "${event.type}" failed due to: ${error.message}`));
+      }
+      if (actions.length === 0)
+        continue;
+      nativeEventPrevented = actions.some((action) => action.type === "raise" || action.type === "execute") || !actions.some((action) => action.type === "forward");
+      let undoStepCreated = !1;
+      actionSetIndex > 0 && (createUndoStep(editor), undoStepCreated = !0), !undoStepCreated && actions.some((action) => action.type === "execute") && (createUndoStep(editor), undoStepCreated = !0);
+      const actionTypes = actions.map((action) => action.type), uniqueActionTypes = new Set(actionTypes), raiseGroup = actionTypes.length > 1 && uniqueActionTypes.size === 1 && uniqueActionTypes.has("raise"), executeGroup = actionTypes.length > 1 && uniqueActionTypes.size === 1 && uniqueActionTypes.has("execute");
+      withoutNormalizingConditional(editor, () => raiseGroup || executeGroup, () => {
+        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: mode === "execute" ? "execute" : "forward",
               behaviors,
-              remainingEventBehaviors: [],
+              remainingEventBehaviors: remainingEventBehaviors2,
               event: action.event,
               editor,
               keyGenerator,
               schema,
               getSnapshot,
-              nativeEvent: void 0,
+              nativeEvent,
               sendBack
             });
+            continue;
           }
-        }), undoStepCreated && clearUndoStep(editor);
-      }
-      break;
+          if (action.type === "raise") {
+            performEvent({
+              mode: mode === "execute" ? "execute" : "raise",
+              behaviors,
+              remainingEventBehaviors: mode === "execute" ? remainingEventBehaviors : behaviors,
+              event: action.event,
+              editor,
+              keyGenerator,
+              schema,
+              getSnapshot,
+              nativeEvent,
+              sendBack
+            });
+            continue;
+          }
+          performEvent({
+            mode: "execute",
+            behaviors,
+            remainingEventBehaviors: [],
+            event: action.event,
+            editor,
+            keyGenerator,
+            schema,
+            getSnapshot,
+            nativeEvent: void 0,
+            sendBack
+          });
+        }
+      }), undoStepCreated && clearUndoStep(editor);
     }
+    break;
   }
   !defaultBehaviorOverwritten && isSyntheticBehaviorEvent(event) ? (nativeEvent?.preventDefault(), mode === "send" && clearUndoStep(editor), withPerformingBehaviorOperation(editor, () => {
     debug$6(`(execute:${eventCategory(event)})`, JSON.stringify(event, null, 2)), performOperation({