@portabletext/editor 1.1.12 → 1.2.1

package/lib/index.js

@@ -812,6 +812,17 @@ function getFocusBlockObject(context) {
   const focusBlock = getFocusBlock(context);
   return focusBlock && !types.isPortableTextTextBlock(focusBlock.node) ? { node: focusBlock.node, path: focusBlock.path } : void 0;
 }
+function getFocusChild(context) {
+  const focusBlock = getFocusTextBlock(context);
+  if (!focusBlock)
+    return;
+  const key = context.selection && types.isKeySegment(context.selection.focus.path[2]) ? context.selection.focus.path[2]._key : void 0, node = key ? focusBlock.node.children.find((span) => span._key === key) : void 0;
+  return node && key ? { node, path: [...focusBlock.path, "children", { _key: key }] } : void 0;
+}
+function getFocusSpan(context) {
+  const focusChild = getFocusChild(context);
+  return focusChild && types.isPortableTextSpan(focusChild.node) ? { node: focusChild.node, path: focusChild.path } : void 0;
+}
 function getSelectionStartBlock(context) {
   const key = context.selection.backward ? types.isKeySegment(context.selection.focus.path[0]) ? context.selection.focus.path[0]._key : void 0 : types.isKeySegment(context.selection.anchor.path[0]) ? context.selection.anchor.path[0]._key : void 0, node = key ? context.value.find((block) => block._key === key) : void 0;
   return node && key ? { node, path: [{ _key: key }] } : void 0;
@@ -858,11 +869,7 @@ function getNextBlock(context) {
 function isEmptyTextBlock(block) {
   return block.children.length === 1 && block.children[0].text === "";
 }
-const softReturn = {
-  on: "insert soft break",
-  actions: [() => [{ type: "insert text", text: `
-` }]]
-}, breakingVoidBlock = {
+const breakingVoidBlock = {
   on: "insert break",
   guard: ({ context }) => !!getFocusBlockObject(context),
   actions: [() => [{ type: "insert text block", decorators: [] }]]
@@ -914,11 +921,48 @@ const softReturn = {
       }
     ]
   ]
-}, coreBehaviors = [
-  softReturn,
+}, coreBlockObjectBehaviors = [
   breakingVoidBlock,
   deletingEmptyTextBlockAfterBlockObject,
   deletingEmptyTextBlockBeforeBlockObject
+], clearListOnBackspace = {
+  on: "delete backward",
+  guard: ({ context }) => {
+    const selectionCollapsed = selectionIsCollapsed(context), focusTextBlock = getFocusTextBlock(context), focusSpan = getFocusSpan(context);
+    return !selectionCollapsed || !focusTextBlock || !focusSpan ? !1 : focusTextBlock.node.children[0]._key === focusSpan.node._key && context.selection.focus.offset === 0 && focusTextBlock.node.level === 1 ? { focusTextBlock } : !1;
+  },
+  actions: [
+    (_, { focusTextBlock }) => [
+      {
+        type: "unset block",
+        props: ["listItem", "level"],
+        paths: [focusTextBlock.path]
+      }
+    ]
+  ]
+}, unindentListOnBackspace = {
+  on: "delete backward",
+  guard: ({ context }) => {
+    const selectionCollapsed = selectionIsCollapsed(context), focusTextBlock = getFocusTextBlock(context), focusSpan = getFocusSpan(context);
+    return !selectionCollapsed || !focusTextBlock || !focusSpan ? !1 : focusTextBlock.node.children[0]._key === focusSpan.node._key && context.selection.focus.offset === 0 && focusTextBlock.node.level !== void 0 && focusTextBlock.node.level > 1 ? { focusTextBlock, level: focusTextBlock.node.level - 1 } : !1;
+  },
+  actions: [
+    (_, { focusTextBlock, level }) => [
+      {
+        type: "set block",
+        level,
+        paths: [focusTextBlock.path]
+      }
+    ]
+  ]
+}, coreListBehaviors = [clearListOnBackspace, unindentListOnBackspace], softReturn = {
+  on: "insert soft break",
+  actions: [() => [{ type: "insert text", text: `
+` }]]
+}, coreBehaviors = [
+  softReturn,
+  ...coreBlockObjectBehaviors,
+  ...coreListBehaviors
 ], debug$k = debugWithName("operationToPatches");
 function createOperationToPatches(types2) {
   const textBlockName = types2.block.name;
@@ -3303,6 +3347,9 @@ function createWithPortableTextLists(types2) {
     }, editor;
   };
 }
+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"));
+}
 function isPortableTextBlock(node) {
   return (
     // A block doesn't _have_ to be named 'block' - to differentiate between
@@ -3468,6 +3515,71 @@ function createWithPortableTextMarkModel(editorActor, types2) {
         apply2(op);
         return;
       }
+      if (op.type === "set_selection" && slate.Editor.marks(editor) && op.properties && op.newProperties && op.properties.anchor && op.properties.focus && op.newProperties.anchor && op.newProperties.focus) {
+        const previousSelectionIsCollapsed = slate.Range.isCollapsed({
+          anchor: op.properties.anchor,
+          focus: op.properties.focus
+        }), newSelectionIsCollapsed = slate.Range.isCollapsed({
+          anchor: op.newProperties.anchor,
+          focus: op.newProperties.focus
+        });
+        if (previousSelectionIsCollapsed && newSelectionIsCollapsed) {
+          const focusSpan = Array.from(
+            slate.Editor.nodes(editor, {
+              mode: "lowest",
+              at: op.properties.focus,
+              match: (n) => editor.isTextSpan(n),
+              voids: !1
+            })
+          )[0]?.[0], newFocusSpan = Array.from(
+            slate.Editor.nodes(editor, {
+              mode: "lowest",
+              at: op.newProperties.focus,
+              match: (n) => editor.isTextSpan(n),
+              voids: !1
+            })
+          )[0]?.[0], movedToNextSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] + 1 && focusSpan.text.length === op.properties.focus.offset && op.newProperties.focus.offset === 0, movedToPreviousSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] - 1 && op.properties.focus.offset === 0 && newFocusSpan.text.length === op.newProperties.focus.offset;
+          if (movedToNextSpan || movedToPreviousSpan)
+            return;
+        }
+      }
+      if (op.type === "insert_node") {
+        const { selection } = editor;
+        if (selection) {
+          const [_block, blockPath] = slate.Editor.node(editor, selection, { depth: 1 }), previousSpan = getPreviousSpan({
+            editor,
+            blockPath,
+            spanPath: op.path
+          }), previousSpanAnnotations = previousSpan ? previousSpan.marks?.filter((mark) => !decorators.includes(mark)) : [], nextSpan = getNextSpan({
+            editor,
+            blockPath,
+            spanPath: [op.path[0], op.path[1] - 1]
+          }), nextSpanAnnotations = nextSpan ? nextSpan.marks?.filter((mark) => !decorators.includes(mark)) : [], annotationsEnding = previousSpanAnnotations?.filter(
+            (annotation) => !nextSpanAnnotations?.includes(annotation)
+          ) ?? [];
+          if (annotationsEnding.length > 0 && isPortableTextSpan(op.node) && op.node.marks?.some((mark) => annotationsEnding.includes(mark))) {
+            slate.Transforms.insertNodes(editor, {
+              ...op.node,
+              marks: op.node.marks?.filter(
+                (mark) => !annotationsEnding.includes(mark)
+              ) ?? []
+            });
+            return;
+          }
+          const annotationsStarting = nextSpanAnnotations?.filter(
+            (annotation) => !previousSpanAnnotations?.includes(annotation)
+          ) ?? [];
+          if (annotationsStarting.length > 0 && isPortableTextSpan(op.node) && op.node.marks?.some((mark) => annotationsStarting.includes(mark))) {
+            slate.Transforms.insertNodes(editor, {
+              ...op.node,
+              marks: op.node.marks?.filter(
+                (mark) => !annotationsStarting.includes(mark)
+              ) ?? []
+            });
+            return;
+          }
+        }
+      }
       if (op.type === "insert_text") {
         const { selection } = editor, collapsedSelection = selection ? slate.Range.isCollapsed(selection) : !1;
         if (selection && collapsedSelection) {
@@ -3484,25 +3596,41 @@ function createWithPortableTextMarkModel(editorActor, types2) {
             (mark) => decorators.includes(mark)
           ), spanHasAnnotations = marks.length > marksWithoutAnnotations.length, spanIsEmpty = span.text.length === 0, atTheBeginningOfSpan = selection.anchor.offset === 0, atTheEndOfSpan = selection.anchor.offset === span.text.length, previousSpan = getPreviousSpan({ editor, blockPath, spanPath }), nextSpan = getNextSpan({ editor, blockPath, spanPath }), nextSpanAnnotations = nextSpan?.marks?.filter((mark) => !decorators.includes(mark)) ?? [], spanAnnotations = marks.filter(
             (mark) => !decorators.includes(mark)
-          ), previousSpanHasSameAnnotation = previousSpan ? previousSpan.marks?.some(
+          ), previousSpanHasAnnotations = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark)) : !1, previousSpanHasSameAnnotations = previousSpan ? previousSpan.marks?.filter((mark) => !decorators.includes(mark)).every((mark) => marks.includes(mark)) : !1, previousSpanHasSameAnnotation = previousSpan ? previousSpan.marks?.some(
             (mark) => !decorators.includes(mark) && marks.includes(mark)
           ) : !1, previousSpanHasSameMarks = previousSpan ? previousSpan.marks?.every((mark) => marks.includes(mark)) : !1, nextSpanSharesSomeAnnotations = spanAnnotations.some(
             (mark) => nextSpanAnnotations?.includes(mark)
           );
           if (spanHasAnnotations && !spanIsEmpty) {
             if (atTheBeginningOfSpan) {
-              previousSpanHasSameMarks ? slate.Transforms.insertNodes(editor, {
-                _type: "span",
-                _key: editorActor.getSnapshot().context.keyGenerator(),
-                text: op.text,
-                marks: previousSpan?.marks ?? []
-              }) : previousSpanHasSameAnnotation ? apply2(op) : slate.Transforms.insertNodes(editor, {
-                _type: "span",
-                _key: editorActor.getSnapshot().context.keyGenerator(),
-                text: op.text,
-                marks: []
-              });
-              return;
+              if (previousSpanHasSameMarks) {
+                slate.Transforms.insertNodes(editor, {
+                  _type: "span",
+                  _key: editorActor.getSnapshot().context.keyGenerator(),
+                  text: op.text,
+                  marks: previousSpan?.marks ?? []
+                });
+                return;
+              } else if (previousSpanHasSameAnnotations) {
+                slate.Transforms.insertNodes(editor, {
+                  _type: "span",
+                  _key: editorActor.getSnapshot().context.keyGenerator(),
+                  text: op.text,
+                  marks: previousSpan?.marks ?? []
+                });
+                return;
+              } else if (previousSpanHasSameAnnotation) {
+                apply2(op);
+                return;
+              } else if (!previousSpan) {
+                slate.Transforms.insertNodes(editor, {
+                  _type: "span",
+                  _key: editorActor.getSnapshot().context.keyGenerator(),
+                  text: op.text,
+                  marks: []
+                });
+                return;
+              }
             }
             if (atTheEndOfSpan) {
               if (nextSpan && nextSpanSharesSomeAnnotations && nextSpanAnnotations.length < spanAnnotations.length || !nextSpanSharesSomeAnnotations) {
@@ -3530,7 +3658,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
               _type: "span",
               _key: editorActor.getSnapshot().context.keyGenerator(),
               text: op.text,
-              marks: (previousSpan.marks ?? []).filter(
+              marks: previousSpanHasAnnotations ? [] : (previousSpan.marks ?? []).filter(
                 (mark) => decorators.includes(mark)
               )
             });