@portabletext/editor 1.2.0 → 1.2.1

package/lib/index.js

@@ -3347,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
@@ -3512,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) {
@@ -3528,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) {
@@ -3574,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)
               )
             });