@portabletext/editor 1.1.2 → 1.1.4

package/lib/index.d.mts

@@ -2260,7 +2260,7 @@ export declare class PortableTextEditor extends Component<PortableTextEditorProp
     editor: PortableTextEditor,
     element: PortableTextBlock | PortableTextChild,
   ) => boolean | undefined
-  static isObjectPath: (editor: PortableTextEditor, path: Path) => boolean
+  static isObjectPath: (_editor: PortableTextEditor, path: Path) => boolean
   static marks: (editor: PortableTextEditor) => string[] | undefined
   static select: (
     editor: PortableTextEditor,

package/lib/index.d.ts

@@ -2260,7 +2260,7 @@ export declare class PortableTextEditor extends Component<PortableTextEditorProp
     editor: PortableTextEditor,
     element: PortableTextBlock | PortableTextChild,
   ) => boolean | undefined
-  static isObjectPath: (editor: PortableTextEditor, path: Path) => boolean
+  static isObjectPath: (_editor: PortableTextEditor, path: Path) => boolean
   static marks: (editor: PortableTextEditor) => string[] | undefined
   static select: (
     editor: PortableTextEditor,

package/lib/index.esm.js

@@ -1577,19 +1577,29 @@ function createWithInsertBreak(types, keyGenerator) {
         insertBreak();
         return;
       }
-      const focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = Node.descendant(editor, focusBlockPath);
+      const [focusSpan] = Array.from(
+        Editor.nodes(editor, {
+          mode: "lowest",
+          at: editor.selection.focus,
+          match: (n) => editor.isTextSpan(n),
+          voids: !1
+        })
+      )[0] ?? [void 0], focusDecorators = focusSpan.marks?.filter(
+        (mark) => types.decorators.some((decorator) => decorator.value === mark)
+      ) ?? [], focusAnnotations = focusSpan.marks?.filter(
+        (mark) => !types.decorators.some((decorator) => decorator.value === mark)
+      ) ?? [], focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = Node.descendant(editor, focusBlockPath);
       if (editor.isTextBlock(focusBlock)) {
         const [start, end] = Range.edges(editor.selection), isEndAtStartOfBlock = isEqual(end, {
           path: [...focusBlockPath, 0],
           offset: 0
         });
         if (isEndAtStartOfBlock && Range.isCollapsed(editor.selection)) {
-          const focusDecorators = editor.isTextSpan(focusBlock.children[0]) ? (focusBlock.children[0].marks ?? []).filter(
-            (mark) => types.decorators.some((decorator) => decorator.value === mark)
-          ) : [];
           Editor.insertNode(
             editor,
-            editor.pteCreateTextBlock({ decorators: focusDecorators })
+            editor.pteCreateTextBlock({
+              decorators: focusAnnotations.length === 0 ? focusDecorators : []
+            })
           );
           const [nextBlockPath] = Path.next(focusBlockPath);
           Transforms.select(editor, {
@@ -1602,6 +1612,24 @@ function createWithInsertBreak(types, keyGenerator) {
           path: [...focusBlockPath, focusBlock.children.length - 1],
           offset: editor.isTextSpan(lastFocusBlockChild) ? lastFocusBlockChild.text.length : 0
         });
+        if (isStartAtEndOfBlock && Range.isCollapsed(editor.selection) && focusDecorators.length > 0 && focusAnnotations.length > 0) {
+          Editor.withoutNormalizing(editor, () => {
+            if (!editor.selection)
+              return;
+            Editor.insertNode(
+              editor,
+              editor.pteCreateTextBlock({
+                decorators: []
+              })
+            );
+            const [nextBlockPath] = Path.next(focusBlockPath);
+            Transforms.setSelection(editor, {
+              anchor: { path: [nextBlockPath, 0], offset: 0 },
+              focus: { path: [nextBlockPath, 0], offset: 0 }
+            });
+          }), editor.onChange();
+          return;
+        }
         if (!isEndAtStartOfBlock && !isStartAtEndOfBlock) {
           Editor.withoutNormalizing(editor, () => {
             if (!editor.selection)
@@ -2458,7 +2486,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(
@@ -2472,7 +2499,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);
@@ -2486,7 +2513,7 @@ NEW PATCH =============================================================`
     } catch (err) {
       console.error(err);
     }
-    return previousPatch = patch, changed;
+    return changed;
   };
 }
 function diffMatchPatch(editor, patch) {
@@ -2601,11 +2628,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 Transforms.deselect(editor), editor.children.forEach((c, i) => {
+    return Transforms.deselect(editor), editor.children.forEach((_child, i) => {
       Transforms.removeNodes(editor, { at: [i] });
     }), Transforms.insertNodes(editor, editor.pteCreateTextBlock({ decorators: [] })), previousSelection && Transforms.select(editor, {
       anchor: { path: [0, 0], offset: 0 },
@@ -3371,29 +3398,67 @@ function createWithPortableTextMarkModel(editorActor, types, keyGenerator) {
         return;
       }
       if (op.type === "insert_text") {
-        const { selection } = editor;
-        if (selection && Range.isCollapsed(selection) && Editor.marks(editor)?.marks?.some(
-          (mark) => !decorators.includes(mark)
-        )) {
-          const [node] = Array.from(
+        const { selection } = editor, collapsedSelection = selection ? Range.isCollapsed(selection) : !1;
+        if (selection && collapsedSelection) {
+          const [_block, blockPath] = Editor.node(editor, selection, {
+            depth: 1
+          }), [span, spanPath] = Array.from(
             Editor.nodes(editor, {
               mode: "lowest",
               at: selection.focus,
-              match: (n) => n._type === types.span.name,
+              match: (n) => editor.isTextSpan(n),
               voids: !1
             })
-          )[0] || [void 0];
-          if (Text.isText(node) && node.text.length === selection.focus.offset && Array.isArray(node.marks) && node.marks.length > 0) {
-            const marksWithoutAnnotationMarks = ({
-              ...Editor.marks(editor) || {}
-            }.marks || []).filter((mark) => decorators.includes(mark));
-            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 Node.children(editor, blockPath, {
+            reverse: !0
+          }))
+            if (editor.isTextSpan(child) && Path.isBefore(childPath, spanPath)) {
+              previousSpan = child;
+              break;
+            }
+          for (const [child, childPath] of Node.children(editor, blockPath))
+            if (editor.isTextSpan(child) && 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 ? Transforms.insertNodes(editor, {
+                _type: "span",
+                _key: keyGenerator(),
+                text: op.text,
+                marks: previousSpan?.marks ?? []
+              }) : previousSpanHasSameAnnotation ? apply2(op) : Transforms.insertNodes(editor, {
+                _type: "span",
+                _key: keyGenerator(),
+                text: op.text,
+                marks: []
+              });
+              return;
+            }
+            if (atTheEndOfSpan) {
+              nextSpanHasSameMarks ? Transforms.insertNodes(editor, {
+                _type: "span",
+                _key: keyGenerator(),
+                text: op.text,
+                marks: nextSpan?.marks ?? []
+              }) : nextSpanHasSameAnnotation ? apply2(op) : Transforms.insertNodes(editor, {
+                _type: "span",
+                _key: keyGenerator(),
+                text: op.text,
+                marks: []
+              });
+              return;
+            }
           }
         }
       }
@@ -4981,7 +5046,7 @@ class PortableTextEditor extends 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;
@@ -5482,7 +5547,7 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     [props, slateEditor]
   ), scrollSelectionIntoViewToSlate = useMemo(() => {
     if (scrollSelectionIntoView !== void 0)
-      return scrollSelectionIntoView === null ? noop : (editor, domRange) => {
+      return scrollSelectionIntoView === null ? noop : (_editor, domRange) => {
         scrollSelectionIntoView(portableTextEditor, domRange);
       };
   }, [portableTextEditor, scrollSelectionIntoView]), decorate = useCallback(