@portabletext/editor 1.1.2 → 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)
@@ -2441,7 +2469,6 @@ function toInt(num) {
 }
 const debug$i = debugWithName("applyPatches"), debugVerbose$4 = debug$i.enabled && !0;
 function createApplyPatch(schemaTypes) {
-  let previousPatch;
   return (editor, patch) => {
     let changed = !1;
     debugVerbose$4 && (debug$i(
@@ -2455,7 +2482,7 @@ NEW PATCH =============================================================`
           changed = insertPatch(editor, patch, schemaTypes);
           break;
         case "unset":
-          changed = unsetPatch(editor, patch, previousPatch);
+          changed = unsetPatch(editor, patch);
           break;
         case "set":
           changed = setPatch(editor, patch);
@@ -2469,7 +2496,7 @@ NEW PATCH =============================================================`
     } catch (err) {
       console.error(err);
     }
-    return previousPatch = patch, changed;
+    return changed;
   };
 }
 function diffMatchPatch(editor, patch) {
@@ -2584,11 +2611,11 @@ function setPatch(editor, patch) {
   }
   return debugState(editor, "after"), !0;
 }
-function unsetPatch(editor, patch, previousPatch) {
+function unsetPatch(editor, patch) {
   if (patch.path.length === 0) {
     debug$i("Removing everything"), debugState(editor, "before");
     const previousSelection = editor.selection;
-    return slate.Transforms.deselect(editor), editor.children.forEach((c, i) => {
+    return slate.Transforms.deselect(editor), editor.children.forEach((_child, i) => {
       slate.Transforms.removeNodes(editor, { at: [i] });
     }), slate.Transforms.insertNodes(editor, editor.pteCreateTextBlock({ decorators: [] })), previousSelection && slate.Transforms.select(editor, {
       anchor: { path: [0, 0], offset: 0 },
@@ -3354,29 +3381,67 @@ function createWithPortableTextMarkModel(editorActor, types2, keyGenerator) {
         return;
       }
       if (op.type === "insert_text") {
-        const { selection } = editor;
-        if (selection && slate.Range.isCollapsed(selection) && slate.Editor.marks(editor)?.marks?.some(
-          (mark) => !decorators.includes(mark)
-        )) {
-          const [node] = Array.from(
+        const { selection } = editor, collapsedSelection = selection ? slate.Range.isCollapsed(selection) : !1;
+        if (selection && collapsedSelection) {
+          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) => n._type === types2.span.name,
+              match: (n) => editor.isTextSpan(n),
               voids: !1
             })
-          )[0] || [void 0];
-          if (slate.Text.isText(node) && node.text.length === selection.focus.offset && Array.isArray(node.marks) && node.marks.length > 0) {
-            const marksWithoutAnnotationMarks = ({
-              ...slate.Editor.marks(editor) || {}
-            }.marks || []).filter((mark) => decorators.includes(mark));
-            slate.Transforms.insertNodes(editor, {
-              _type: "span",
-              _key: keyGenerator(),
-              text: op.text,
-              marks: marksWithoutAnnotationMarks
-            }), debug$c("Inserting text at end of annotation");
-            return;
+          )[0] ?? [void 0, void 0], marks = span.marks ?? [], marksWithoutAnnotations = marks.filter(
+            (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;
+          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;
+            }
           }
         }
       }
@@ -4964,7 +5029,7 @@ class PortableTextEditor extends react.Component {
   static insertBlock = (editor, type, value) => editor.editable?.insertBlock(type, value);
   static insertBreak = (editor) => editor.editable?.insertBreak();
   static isVoid = (editor, element) => editor.editable?.isVoid(element);
-  static isObjectPath = (editor, path) => {
+  static isObjectPath = (_editor, path) => {
     if (!path || !Array.isArray(path)) return !1;
     const isChildObjectEditPath = path.length > 3 && path[1] === "children";
     return path.length > 1 && path[1] !== "children" || isChildObjectEditPath;
@@ -5465,7 +5530,7 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     [props, slateEditor]
   ), scrollSelectionIntoViewToSlate = react.useMemo(() => {
     if (scrollSelectionIntoView !== void 0)
-      return scrollSelectionIntoView === null ? noop__default.default : (editor, domRange) => {
+      return scrollSelectionIntoView === null ? noop__default.default : (_editor, domRange) => {
         scrollSelectionIntoView(portableTextEditor, domRange);
       };
   }, [portableTextEditor, scrollSelectionIntoView]), decorate = react.useCallback(