@portabletext/editor 1.44.14 → 1.44.16

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

@@ -2670,74 +2670,10 @@ function createOperationToPatches(types2) {
     splitNodePatch
   };
 }
-const insertBreakActionImplementation = ({
-  context,
-  action
-}) => {
-  const keyGenerator = context.keyGenerator, schema2 = 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 = slate.Node.descendant(editor, focusBlockPath);
-  if (editor.isTextBlock(focusBlock) && anchorBlockPath[0] === focusBlockPath[0]) {
-    slate.Transforms.splitNodes(editor, {
-      at: editor.selection,
-      always: !0
-    });
-    const [nextBlock, nextBlockPath] = slate.Editor.node(editor, slate.Path.next(focusBlockPath), {
-      depth: 1
-    }), nextChild = slate.Node.child(nextBlock, 0);
-    if (!editor.isTextSpan(nextChild) && slate.Transforms.insertNodes(editor, {
-      _key: context.keyGenerator(),
-      _type: "span",
-      text: "",
-      marks: []
-    }, {
-      at: [nextBlockPath[0], 0]
-    }), slate.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(slate.Node.children(editor, focusBlockPath)).map((entry) => entry[0]).filter((node) => editor.isTextSpan(node)), children = slate.Node.children(editor, nextBlockPath);
-      for (const [child, childPath] of children) {
-        if (!editor.isTextSpan(child))
-          continue;
-        const marks = child.marks ?? [];
-        for (const mark of marks)
-          schema2.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__default.default(marks, newMarks) || slate.Transforms.setNodes(editor, {
-          marks: newMarks
-        }, {
-          at: childPath
-        });
-      }
-      const newMarkDefs = nextBlock.markDefs.map((markDef) => ({
-        ...markDef,
-        _key: newMarkDefKeys.get(markDef._key) ?? markDef._key
-      }));
-      isEqual__default.default(nextBlock.markDefs, newMarkDefs) || slate.Transforms.setNodes(editor, {
-        markDefs: newMarkDefs
-      }, {
-        at: nextBlockPath,
-        match: (node) => editor.isTextBlock(node)
-      });
-    }
-    return;
-  }
-  slate.Transforms.splitNodes(editor, {
-    always: !0
-  });
-}, insertSoftBreakActionImplementation = ({
+const insertTextActionImplementation = ({
   action
 }) => {
-  slate.insertText(action.editor, `
-`);
+  action.editor.insertText(action.text);
 };
 function isPortableTextSpan(node) {
   return node._type === "span" && "text" in node && typeof node.text == "string" && (typeof node.marks > "u" || Array.isArray(node.marks) && node.marks.every((mark) => typeof mark == "string"));
@@ -4063,11 +3999,7 @@ function insertBlock({
     }
   }
 }
-const insertTextActionImplementation = ({
-  action
-}) => {
-  action.editor.insertText(action.text);
-}, moveBlockActionImplementation = ({
+const moveBlockActionImplementation = ({
   action
 }) => {
   const at = [toSlatePath(action.at, action.editor)[0]], to = [toSlatePath(action.to, action.editor)[0]];
@@ -4082,6 +4014,69 @@ const insertTextActionImplementation = ({
 }) => {
   const newSelection = toSlateRange(action.selection, action.editor);
   newSelection ? slate.Transforms.select(action.editor, newSelection) : slate.Transforms.deselect(action.editor);
+}, splitBlockActionImplementation = ({
+  context,
+  action
+}) => {
+  const keyGenerator = context.keyGenerator, schema2 = 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 = slate.Node.descendant(editor, focusBlockPath);
+  if (editor.isTextBlock(focusBlock) && anchorBlockPath[0] === focusBlockPath[0]) {
+    slate.Transforms.splitNodes(editor, {
+      at: editor.selection,
+      always: !0
+    });
+    const [nextBlock, nextBlockPath] = slate.Editor.node(editor, slate.Path.next(focusBlockPath), {
+      depth: 1
+    }), nextChild = slate.Node.child(nextBlock, 0);
+    if (!editor.isTextSpan(nextChild) && slate.Transforms.insertNodes(editor, {
+      _key: context.keyGenerator(),
+      _type: "span",
+      text: "",
+      marks: []
+    }, {
+      at: [nextBlockPath[0], 0]
+    }), slate.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(slate.Node.children(editor, focusBlockPath)).map((entry) => entry[0]).filter((node) => editor.isTextSpan(node)), children = slate.Node.children(editor, nextBlockPath);
+      for (const [child, childPath] of children) {
+        if (!editor.isTextSpan(child))
+          continue;
+        const marks = child.marks ?? [];
+        for (const mark of marks)
+          schema2.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__default.default(marks, newMarks) || slate.Transforms.setNodes(editor, {
+          marks: newMarks
+        }, {
+          at: childPath
+        });
+      }
+      const newMarkDefs = nextBlock.markDefs.map((markDef) => ({
+        ...markDef,
+        _key: newMarkDefKeys.get(markDef._key) ?? markDef._key
+      }));
+      isEqual__default.default(nextBlock.markDefs, newMarkDefs) || slate.Transforms.setNodes(editor, {
+        markDefs: newMarkDefs
+      }, {
+        at: nextBlockPath,
+        match: (node) => editor.isTextBlock(node)
+      });
+    }
+    return;
+  }
+  slate.Transforms.splitNodes(editor, {
+    always: !0
+  });
 }, debug$a = debugWithName("behaviors:action"), behaviorActionImplementations = {
   "annotation.add": addAnnotationActionImplementation,
   "annotation.remove": removeAnnotationActionImplementation,
@@ -4099,15 +4094,14 @@ const insertTextActionImplementation = ({
   "history.redo": historyRedoActionImplementation,
   "history.undo": historyUndoActionImplementation,
   "insert.block": insertBlockActionImplementation,
-  "insert.break": insertBreakActionImplementation,
   "insert.inline object": insertInlineObjectActionImplementation,
-  "insert.soft break": insertSoftBreakActionImplementation,
   "insert.span": insertSpanActionImplementation,
   "insert.text": insertTextActionImplementation,
   effect: effectActionImplementation,
   "move.block": moveBlockActionImplementation,
   noop: noopActionImplementation,
-  select: selectActionImplementation
+  select: selectActionImplementation,
+  "split.block": splitBlockActionImplementation
 };
 function performAction({
   context,
@@ -4240,20 +4234,6 @@ function performAction({
       });
       break;
     }
-    case "insert.break": {
-      behaviorActionImplementations["insert.break"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "insert.soft break": {
-      behaviorActionImplementations["insert.soft break"]({
-        context,
-        action
-      });
-      break;
-    }
     case "insert.span": {
       behaviorActionImplementations["insert.span"]({
         context,
@@ -4277,6 +4257,13 @@ function performAction({
     }
     case "noop":
       break;
+    case "split.block": {
+      behaviorActionImplementations["split.block"]({
+        context,
+        action
+      });
+      break;
+    }
     default: {
       behaviorActionImplementations.select({
         context,
@@ -4350,12 +4337,14 @@ function createWithEventListeners(editorActor) {
       });
     }, editor.insertSoftBreak = () => {
       if (isApplyingBehaviorActions(editor)) {
-        insertSoftBreakActionImplementation({
+        insertTextActionImplementation({
           context: {
             keyGenerator: editorActor.getSnapshot().context.keyGenerator,
             schema: editorActor.getSnapshot().context.schema
           },
           action: {
+            text: `
+`,
             editor
           }
         });
@@ -5309,7 +5298,7 @@ const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
     placement: "auto",
     select: "end"
   })] : event.blocks.flatMap((block, index) => index === 0 ? [behavior_core.raise({
-    type: "insert.break"
+    type: "split.block"
   }), behavior_core.raise({
     type: "select.previous block",
     select: "end"
@@ -5345,6 +5334,18 @@ const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
     placement: index === 0 ? "auto" : "after",
     select: "end"
   }))]
+}), behavior_core.defineBehavior({
+  on: "insert.break",
+  actions: [() => [behavior_core.raise({
+    type: "split.block"
+  })]]
+}), behavior_core.defineBehavior({
+  on: "insert.soft break",
+  actions: [() => [behavior_core.raise({
+    type: "insert.text",
+    text: `
+`
+  })]]
 })], abstractListItemBehaviors = [behavior_core.defineBehavior({
   on: "list item.add",
   guard: ({
@@ -5588,20 +5589,29 @@ const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
     snapshot,
     event
   }) => {
-    const deserializeEvents = snapshot.context.converters.flatMap((converter) => {
+    let success;
+    const failures = [];
+    for (const converter of snapshot.context.converters) {
       const data = event.originEvent.originEvent.dataTransfer.getData(converter.mimeType);
-      return data ? [converter.deserialize({
+      if (!data)
+        continue;
+      const deserializeEvent = converter.deserialize({
         snapshot,
         event: {
           type: "deserialize",
           data
         }
-      })] : [];
-    });
-    return deserializeEvents.find((deserializeEvent) => deserializeEvent.type === "deserialization.success") || {
+      });
+      if (deserializeEvent.type === "deserialization.success") {
+        success = deserializeEvent;
+        break;
+      } else
+        failures.push(deserializeEvent);
+    }
+    return success || {
       type: "deserialization.failure",
       mimeType: "*/*",
-      reason: deserializeEvents.map((deserializeEvent) => deserializeEvent.type === "deserialization.failure" ? deserializeEvent.reason : "").join(", ")
+      reason: failures.map((failure) => failure.reason).join(", ")
     };
   },
   actions: [({
@@ -5920,7 +5930,7 @@ const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
   raiseDeserializationSuccessOrFailure,
   raiseSerializationSuccessOrFailure,
   raiseInsertSoftBreak
-], abstractBehaviorEventTypes = ["annotation.toggle", "decorator.toggle", "deserialize", "deserialization.success", "deserialization.failure", "insert.blocks", "list item.add", "list item.remove", "list item.toggle", "move.block down", "move.block up", "select.previous block", "select.next block", "serialize", "serialization.success", "serialization.failure", "style.add", "style.remove", "style.toggle"];
+], abstractBehaviorEventTypes = ["annotation.toggle", "decorator.toggle", "deserialize", "deserialization.success", "deserialization.failure", "insert.blocks", "insert.break", "insert.soft break", "list item.add", "list item.remove", "list item.toggle", "move.block down", "move.block up", "select.previous block", "select.next block", "serialize", "serialization.success", "serialization.failure", "style.add", "style.remove", "style.toggle"];
 function isAbstractBehaviorEvent(event) {
   return abstractBehaviorEventTypes.includes(event.type);
 }