@portabletext/editor 1.0.14 → 1.0.15

package/lib/index.js

@@ -2762,19 +2762,27 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
       change$.next({ type: "selection", selection: ptRange });
     };
     return editor.normalizeNode = (nodeEntry) => {
-      normalizeNode(nodeEntry), editor.operations.some(
-        (op) => [
-          "insert_node",
-          "insert_text",
-          "merge_node",
-          "remove_node",
-          "remove_text",
-          "set_node"
-        ].includes(op.type)
-      ) && mergeSpans(editor);
       const [node, path] = nodeEntry, isSpan = slate.Text.isText(node) && node._type === types2.span.name, isTextBlock = editor.isTextBlock(node);
+      if (editor.isTextBlock(node)) {
+        const children = slate.Node.children(editor, path);
+        for (const [child, childPath] of children) {
+          const nextNode = node.children[childPath[1] + 1];
+          if (editor.isTextSpan(child) && editor.isTextSpan(nextNode) && isEqual__default.default(child.marks, nextNode.marks)) {
+            debug$c(
+              "Merging spans",
+              JSON.stringify(child, null, 2),
+              JSON.stringify(nextNode, null, 2)
+            ), slate.Transforms.mergeNodes(editor, { at: [childPath[0], childPath[1] + 1], voids: !0 });
+            return;
+          }
+        }
+      }
       if (isSpan || isTextBlock) {
-        if (isSpan && !Array.isArray(node.marks) && (debug$c("Adding .marks to span node"), slate.Transforms.setNodes(editor, { marks: [] }, { at: path }), editor.onChange()), isSpan && (node.marks || []).length > 0) {
+        if (isSpan && !Array.isArray(node.marks)) {
+          debug$c("Adding .marks to span node"), slate.Transforms.setNodes(editor, { marks: [] }, { at: path });
+          return;
+        }
+        if (isSpan && (node.marks || []).length > 0) {
           const spanMarks = node.marks || EMPTY_MARKS$1, annotationMarks = spanMarks.filter(
             (mark) => !types2.decorators.map((dec) => dec.value).includes(mark)
           );
@@ -2782,11 +2790,14 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
             const [block] = slate.Editor.node(editor, slate.Path.parent(path)), orphanedMarks = editor.isTextBlock(block) && annotationMarks.filter(
               (mark) => !block.markDefs?.find((def) => def._key === mark)
             ) || [];
-            orphanedMarks.length > 0 && (debug$c("Removing orphaned .marks from span node"), slate.Transforms.setNodes(
-              editor,
-              { marks: spanMarks.filter((mark) => !orphanedMarks.includes(mark)) },
-              { at: path }
-            ), editor.onChange());
+            if (orphanedMarks.length > 0) {
+              debug$c("Removing orphaned .marks from span node"), slate.Transforms.setNodes(
+                editor,
+                { marks: spanMarks.filter((mark) => !orphanedMarks.includes(mark)) },
+                { at: path }
+              );
+              return;
+            }
           }
         }
         for (const op of editor.operations) {
@@ -2794,7 +2805,10 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
             const [targetBlock, targetPath] = slate.Editor.node(editor, [op.path[0] - 1]);
             if (debug$c("Copying markDefs over to merged block", op), editor.isTextBlock(targetBlock)) {
               const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [], newMarkDefs = uniq__default.default([...oldDefs, ...op.properties.markDefs]);
-              isEqual__default.default(newMarkDefs, targetBlock.markDefs) || (slate.Transforms.setNodes(editor, { markDefs: newMarkDefs }, { at: targetPath, voids: !1 }), editor.onChange());
+              if (!isEqual__default.default(newMarkDefs, targetBlock.markDefs)) {
+                slate.Transforms.setNodes(editor, { markDefs: newMarkDefs }, { at: targetPath, voids: !1 });
+                return;
+              }
             }
           }
           if (op.type === "split_node" && op.path.length === 1 && slate.Element.isElementProps(op.properties) && op.properties._type === types2.block.name && "markDefs" in op.properties && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0 && op.path[0] + 1 < editor.children.length) {
@@ -2805,32 +2819,46 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
                 editor,
                 { markDefs: uniq__default.default([...oldDefs, ...op.properties.markDefs]) },
                 { at: targetPath, voids: !1 }
-              ), editor.onChange();
+              );
+              return;
             }
           }
           if (op.type === "split_node" && op.path.length === 2 && op.properties._type === types2.span.name && "marks" in op.properties && Array.isArray(op.properties.marks) && op.properties.marks.length > 0 && op.path[0] + 1 < editor.children.length) {
             const [child, childPath] = slate.Editor.node(editor, [op.path[0] + 1, 0]);
-            slate.Text.isText(child) && child.text === "" && Array.isArray(child.marks) && child.marks.length > 0 && (slate.Transforms.setNodes(editor, { marks: [] }, { at: childPath, voids: !1 }), editor.onChange());
+            if (slate.Text.isText(child) && child.text === "" && Array.isArray(child.marks) && child.marks.length > 0) {
+              slate.Transforms.setNodes(editor, { marks: [] }, { at: childPath, voids: !1 });
+              return;
+            }
           }
           if (op.type === "split_node" && op.path.length === 1 && op.properties._type === types2.block.name && "markDefs" in op.properties && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0) {
             const [block, blockPath] = slate.Editor.node(editor, [op.path[0]]);
-            editor.isTextBlock(block) && block.children.length === 1 && block.markDefs && block.markDefs.length > 0 && slate.Text.isText(block.children[0]) && block.children[0].text === "" && (!block.children[0].marks || block.children[0].marks.length === 0) && (slate.Transforms.setNodes(editor, { markDefs: [] }, { at: blockPath }), editor.onChange());
+            if (editor.isTextBlock(block) && block.children.length === 1 && block.markDefs && block.markDefs.length > 0 && slate.Text.isText(block.children[0]) && block.children[0].text === "" && (!block.children[0].marks || block.children[0].marks.length === 0)) {
+              slate.Transforms.setNodes(editor, { markDefs: [] }, { at: blockPath });
+              return;
+            }
           }
         }
-        isSpan && Array.isArray(node.marks) && (!node.marks || node.marks.length > 0 && node.text === "") && (slate.Transforms.setNodes(editor, { marks: [] }, { at: path, voids: !1 }), editor.onChange());
+        if (isSpan && Array.isArray(node.marks) && (!node.marks || node.marks.length > 0 && node.text === "")) {
+          slate.Transforms.setNodes(editor, { marks: [] }, { at: path, voids: !1 });
+          return;
+        }
       }
       if (editor.isTextBlock(node) && !editor.operations.some(
         (op) => op.type === "merge_node" && "markDefs" in op.properties && op.path.length === 1
       )) {
         const newMarkDefs = (node.markDefs || []).filter((def) => node.children.find((child) => slate.Text.isText(child) && Array.isArray(child.marks) && child.marks.includes(def._key)));
-        node.markDefs && !isEqual__default.default(newMarkDefs, node.markDefs) && (debug$c("Removing markDef not in use"), slate.Transforms.setNodes(
-          editor,
-          {
-            markDefs: newMarkDefs
-          },
-          { at: path }
-        ), editor.onChange());
+        if (node.markDefs && !isEqual__default.default(newMarkDefs, node.markDefs)) {
+          debug$c("Removing markDef not in use"), slate.Transforms.setNodes(
+            editor,
+            {
+              markDefs: newMarkDefs
+            },
+            { at: path }
+          );
+          return;
+        }
       }
+      normalizeNode(nodeEntry);
     }, editor.apply = (op) => {
       if (isChangingRemotely(editor)) {
         apply2(op);
@@ -2902,15 +2930,11 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
       apply2(op);
     }, editor.addMark = (mark) => {
       if (editor.selection) {
-        if (slate.Range.isExpanded(editor.selection)) {
-          slate.Transforms.setNodes(editor, {}, { match: slate.Text.isText, split: !0 });
-          const splitTextNodes = [
-            ...slate.Editor.nodes(editor, { at: editor.selection, match: slate.Text.isText })
-          ];
-          if (splitTextNodes.every((node) => node[0].marks?.includes(mark)))
-            return editor.removeMark(mark), editor;
+        if (slate.Range.isExpanded(editor.selection))
           slate.Editor.withoutNormalizing(editor, () => {
-            splitTextNodes.forEach(([node, path]) => {
+            slate.Transforms.setNodes(editor, {}, { match: slate.Text.isText, split: !0 });
+            const splitTextNodes = slate.Range.isRange(editor.selection) ? [...slate.Editor.nodes(editor, { at: editor.selection, match: slate.Text.isText })] : [];
+            splitTextNodes.length > 1 && splitTextNodes.every((node) => node[0].marks?.includes(mark)) ? editor.removeMark(mark) : splitTextNodes.forEach(([node, path]) => {
               const marks = [
                 ...(Array.isArray(node.marks) ? node.marks : []).filter(
                   (eMark) => eMark !== mark
@@ -2923,8 +2947,8 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
                 { at: path, match: slate.Text.isText, split: !0, hanging: !0 }
               );
             });
-          }), slate.Editor.normalize(editor);
-        } else {
+          });
+        else {
           const existingMarks = {
             ...slate.Editor.marks(editor) || {}
           }.marks || [], marks = {
@@ -2985,25 +3009,6 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
       editor.pteIsMarkActive(mark) ? (debug$c(`Remove mark '${mark}'`), slate.Editor.removeMark(editor, mark)) : (debug$c(`Add mark '${mark}'`), slate.Editor.addMark(editor, mark, !0));
     }, editor;
   };
-  function mergeSpans(editor) {
-    const { selection } = editor;
-    if (selection) {
-      const textNodesInSelection = Array.from(
-        slate.Editor.nodes(editor, {
-          at: slate.Editor.range(editor, [selection.anchor.path[0]], [selection.focus.path[0]]),
-          match: slate.Text.isText,
-          reverse: !0
-        })
-      );
-      for (const [node, path] of textNodesInSelection) {
-        const [parent] = path.length > 1 ? slate.Editor.node(editor, slate.Path.parent(path)) : [void 0], nextPath = [path[0], path[1] + 1];
-        if (editor.isTextBlock(parent)) {
-          const nextNode = parent.children[nextPath[1]];
-          slate.Text.isText(nextNode) && isEqual__default.default(nextNode.marks, node.marks) && (debug$c("Merging spans"), slate.Transforms.mergeNodes(editor, { at: nextPath, voids: !0 }), editor.onChange());
-        }
-      }
-    }
-  }
 }
 const debug$b = debugWithName("plugin:withPortableTextSelections"), debugVerbose$2 = debug$b.enabled && !1;
 function createWithPortableTextSelections(change$, types2) {