@portabletext/editor 1.1.3 → 1.1.4

package/lib/index.js

@@ -1560,19 +1560,29 @@ function createWithInsertBreak(types2, keyGenerator) {
         insertBreak();
         return;
       }
-      const focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
+      const [focusSpan] = Array.from(
+        slate.Editor.nodes(editor, {
+          mode: "lowest",
+          at: editor.selection.focus,
+          match: (n) => editor.isTextSpan(n),
+          voids: !1
+        })
+      )[0] ?? [void 0], focusDecorators = focusSpan.marks?.filter(
+        (mark) => types2.decorators.some((decorator) => decorator.value === mark)
+      ) ?? [], focusAnnotations = focusSpan.marks?.filter(
+        (mark) => !types2.decorators.some((decorator) => decorator.value === mark)
+      ) ?? [], focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
       if (editor.isTextBlock(focusBlock)) {
         const [start, end] = slate.Range.edges(editor.selection), isEndAtStartOfBlock = isEqual__default.default(end, {
           path: [...focusBlockPath, 0],
           offset: 0
         });
         if (isEndAtStartOfBlock && slate.Range.isCollapsed(editor.selection)) {
-          const focusDecorators = editor.isTextSpan(focusBlock.children[0]) ? (focusBlock.children[0].marks ?? []).filter(
-            (mark) => types2.decorators.some((decorator) => decorator.value === mark)
-          ) : [];
           slate.Editor.insertNode(
             editor,
-            editor.pteCreateTextBlock({ decorators: focusDecorators })
+            editor.pteCreateTextBlock({
+              decorators: focusAnnotations.length === 0 ? focusDecorators : []
+            })
           );
           const [nextBlockPath] = slate.Path.next(focusBlockPath);
           slate.Transforms.select(editor, {
@@ -1585,6 +1595,24 @@ function createWithInsertBreak(types2, keyGenerator) {
           path: [...focusBlockPath, focusBlock.children.length - 1],
           offset: editor.isTextSpan(lastFocusBlockChild) ? lastFocusBlockChild.text.length : 0
         });
+        if (isStartAtEndOfBlock && slate.Range.isCollapsed(editor.selection) && focusDecorators.length > 0 && focusAnnotations.length > 0) {
+          slate.Editor.withoutNormalizing(editor, () => {
+            if (!editor.selection)
+              return;
+            slate.Editor.insertNode(
+              editor,
+              editor.pteCreateTextBlock({
+                decorators: []
+              })
+            );
+            const [nextBlockPath] = slate.Path.next(focusBlockPath);
+            slate.Transforms.setSelection(editor, {
+              anchor: { path: [nextBlockPath, 0], offset: 0 },
+              focus: { path: [nextBlockPath, 0], offset: 0 }
+            });
+          }), editor.onChange();
+          return;
+        }
         if (!isEndAtStartOfBlock && !isStartAtEndOfBlock) {
           slate.Editor.withoutNormalizing(editor, () => {
             if (!editor.selection)
@@ -3355,24 +3383,65 @@ function createWithPortableTextMarkModel(editorActor, types2, keyGenerator) {
       if (op.type === "insert_text") {
         const { selection } = editor, collapsedSelection = selection ? slate.Range.isCollapsed(selection) : !1;
         if (selection && collapsedSelection) {
-          const [span] = Array.from(
+          const [_block, blockPath] = slate.Editor.node(editor, selection, {
+            depth: 1
+          }), [span, spanPath] = Array.from(
             slate.Editor.nodes(editor, {
               mode: "lowest",
               at: selection.focus,
               match: (n) => editor.isTextSpan(n),
               voids: !1
             })
-          )[0], marks = span.marks ?? [], marksWithoutAnnotations = marks.filter(
+          )[0] ?? [void 0, void 0], marks = span.marks ?? [], marksWithoutAnnotations = marks.filter(
             (mark) => decorators.includes(mark)
-          );
-          if (marks.length > marksWithoutAnnotations.length && (selection.anchor.offset === 0 || span.text.length === selection.focus.offset)) {
-            slate.Transforms.insertNodes(editor, {
-              _type: "span",
-              _key: keyGenerator(),
-              text: op.text,
-              marks: marksWithoutAnnotations
-            }), debug$c("Inserting text at end of annotation");
-            return;
+          ), spanHasAnnotations = marks.length > marksWithoutAnnotations.length, spanIsEmpty = span.text.length === 0, atTheBeginningOfSpan = selection.anchor.offset === 0, atTheEndOfSpan = selection.anchor.offset === span.text.length;
+          let previousSpan, nextSpan;
+          for (const [child, childPath] of slate.Node.children(editor, blockPath, {
+            reverse: !0
+          }))
+            if (editor.isTextSpan(child) && slate.Path.isBefore(childPath, spanPath)) {
+              previousSpan = child;
+              break;
+            }
+          for (const [child, childPath] of slate.Node.children(editor, blockPath))
+            if (editor.isTextSpan(child) && slate.Path.isAfter(childPath, spanPath)) {
+              nextSpan = child;
+              break;
+            }
+          const previousSpanHasSameAnnotation = previousSpan ? previousSpan.marks?.some(
+            (mark) => !decorators.includes(mark) && marks.includes(mark)
+          ) : !1, previousSpanHasSameMarks = previousSpan ? previousSpan.marks?.every((mark) => marks.includes(mark)) : !1, nextSpanHasSameAnnotation = nextSpan ? nextSpan.marks?.some(
+            (mark) => !decorators.includes(mark) && marks.includes(mark)
+          ) : !1, nextSpanHasSameMarks = nextSpan ? nextSpan.marks?.every((mark) => marks.includes(mark)) : !1;
+          if (spanHasAnnotations && !spanIsEmpty) {
+            if (atTheBeginningOfSpan) {
+              previousSpanHasSameMarks ? slate.Transforms.insertNodes(editor, {
+                _type: "span",
+                _key: keyGenerator(),
+                text: op.text,
+                marks: previousSpan?.marks ?? []
+              }) : previousSpanHasSameAnnotation ? apply2(op) : slate.Transforms.insertNodes(editor, {
+                _type: "span",
+                _key: keyGenerator(),
+                text: op.text,
+                marks: []
+              });
+              return;
+            }
+            if (atTheEndOfSpan) {
+              nextSpanHasSameMarks ? slate.Transforms.insertNodes(editor, {
+                _type: "span",
+                _key: keyGenerator(),
+                text: op.text,
+                marks: nextSpan?.marks ?? []
+              }) : nextSpanHasSameAnnotation ? apply2(op) : slate.Transforms.insertNodes(editor, {
+                _type: "span",
+                _key: keyGenerator(),
+                text: op.text,
+                marks: []
+              });
+              return;
+            }
           }
         }
       }