@portabletext/editor 1.0.17 → 1.0.19

package/lib/index.js

@@ -106,7 +106,7 @@ function normalizeSelection(selection, value) {
   const { anchor, focus } = selection;
   return anchor && value.find((blk) => isEqual__default.default({ _key: blk._key }, anchor.path[0])) && (newAnchor = normalizePoint(anchor, value)), focus && value.find((blk) => isEqual__default.default({ _key: blk._key }, focus.path[0])) && (newFocus = normalizePoint(focus, value)), newAnchor && newFocus ? { anchor: newAnchor, focus: newFocus, backward: selection.backward } : null;
 }
-const EMPTY_MARKDEFS = [], EMPTY_MARKS$1 = [], VOID_CHILD_KEY = "void-child";
+const EMPTY_MARKDEFS = [], VOID_CHILD_KEY = "void-child";
 function keepObjectEquality(object, keyMap) {
   const value = keyMap[object._key];
   return value && isEqual__default.default(object, value) ? value : (keyMap[object._key] = object, object);
@@ -854,24 +854,38 @@ function createOperationToPatches(types2) {
         return [patches.unset([{ _key: block._key }])];
       throw new Error("Block not found");
     } else if (editor.isTextBlock(block) && operation.path.length === 2) {
-      const spanToRemove = editor.isTextBlock(block) && block.children && block.children[operation.path[1]];
-      return spanToRemove ? [patches.unset([{ _key: block._key }, "children", { _key: spanToRemove._key }])] : (debug$k("Span not found in editor trying to remove node"), []);
+      const spanToRemove = block.children[operation.path[1]];
+      return spanToRemove ? block.children.filter((span) => span._key === operation.node._key).length > 1 ? (console.warn(
+        `Multiple spans have \`_key\` ${operation.node._key}. It's ambiguous which one to remove.`,
+        JSON.stringify(block, null, 2)
+      ), []) : [patches.unset([{ _key: block._key }, "children", { _key: spanToRemove._key }])] : (debug$k("Span not found in editor trying to remove node"), []);
     } else
       return debug$k("Not creating patch inside object block"), [];
   }
   function mergeNodePatch(editor, operation, beforeValue) {
-    const patches$1 = [], block = beforeValue[operation.path[0]], targetBlock = editor.children[operation.path[0]];
+    const patches$1 = [], block = beforeValue[operation.path[0]], updatedBlock = editor.children[operation.path[0]];
     if (operation.path.length === 1)
       if (block?._key) {
         const newBlock = fromSlateValue([editor.children[operation.path[0] - 1]], textBlockName)[0];
         patches$1.push(patches.set(newBlock, [{ _key: newBlock._key }])), patches$1.push(patches.unset([{ _key: block._key }]));
       } else
         throw new Error("Target key not found!");
-    else if (operation.path.length === 2 && editor.isTextBlock(targetBlock)) {
-      const mergedSpan = editor.isTextBlock(block) && block.children[operation.path[1]] || void 0, targetSpan = targetBlock.children[operation.path[1] - 1];
-      editor.isTextSpan(targetSpan) && (patches$1.push(
-        patches.set(targetSpan.text, [{ _key: block._key }, "children", { _key: targetSpan._key }, "text"])
-      ), mergedSpan && patches$1.push(patches.unset([{ _key: block._key }, "children", { _key: mergedSpan._key }])));
+    else if (editor.isTextBlock(block) && editor.isTextBlock(updatedBlock) && operation.path.length === 2) {
+      const updatedSpan = updatedBlock.children[operation.path[1] - 1] && editor.isTextSpan(updatedBlock.children[operation.path[1] - 1]) ? updatedBlock.children[operation.path[1] - 1] : void 0, removedSpan = block.children[operation.path[1]] && editor.isTextSpan(block.children[operation.path[1]]) ? block.children[operation.path[1]] : void 0;
+      updatedSpan && (block.children.filter((span) => span._key === updatedSpan._key).length === 1 ? patches$1.push(
+        patches.set(updatedSpan.text, [
+          { _key: block._key },
+          "children",
+          { _key: updatedSpan._key },
+          "text"
+        ])
+      ) : console.warn(
+        `Multiple spans have \`_key\` ${updatedSpan._key}. It's ambiguous which one to update.`,
+        JSON.stringify(block, null, 2)
+      )), removedSpan && (block.children.filter((span) => span._key === removedSpan._key).length === 1 ? patches$1.push(patches.unset([{ _key: block._key }, "children", { _key: removedSpan._key }])) : console.warn(
+        `Multiple spans have \`_key\` ${removedSpan._key}. It's ambiguous which one to remove.`,
+        JSON.stringify(block, null, 2)
+      ));
     } else
       debug$k("Void nodes can't be merged, not creating any patches");
     return patches$1;
@@ -1138,9 +1152,10 @@ function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
           const [block] = slate.Editor.node(editor, originalSelection.focus, { depth: 1 });
           if (!editor.isTextBlock(block))
             return;
-          slate.Range.isCollapsed(originalSelection) && (editor.pteExpandToWord(), editor.onChange());
           const [textNode] = slate.Editor.node(editor, originalSelection.focus, { depth: 2 });
-          editor.selection && (slate.Editor.withoutNormalizing(editor, () => {
+          if (!types.isPortableTextSpan(textNode) || textNode.text === "")
+            return;
+          slate.Range.isCollapsed(originalSelection) && (editor.pteExpandToWord(), editor.onChange()), editor.selection && (slate.Editor.withoutNormalizing(editor, () => {
             const annotationKey = keyGenerator();
             slate.Transforms.setNodes(
               editor,
@@ -2756,7 +2771,7 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
       change$.next({ type: "selection", selection: ptRange });
     };
     return editor.normalizeNode = (nodeEntry) => {
-      const [node, path] = nodeEntry, isSpan = slate.Text.isText(node) && node._type === types2.span.name, isTextBlock = editor.isTextBlock(node);
+      const [node, path] = nodeEntry;
       if (editor.isTextBlock(node)) {
         const children = slate.Node.children(editor, path);
         for (const [child, childPath] of children) {
@@ -2771,65 +2786,47 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
           }
         }
       }
-      if (isSpan || isTextBlock) {
-        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)
+      if (editor.isTextSpan(node) && !Array.isArray(node.marks)) {
+        debug$c("Adding .marks to span node"), slate.Transforms.setNodes(editor, { marks: [] }, { at: path });
+        return;
+      }
+      if (editor.isTextSpan(node)) {
+        const blockPath = slate.Path.parent(path), [block] = slate.Editor.node(editor, blockPath), decorators2 = types2.decorators.map((decorator) => decorator.value), annotations = node.marks?.filter((mark) => !decorators2.includes(mark));
+        if (editor.isTextBlock(block) && node.text === "" && annotations && annotations.length > 0) {
+          debug$c("Removing annotations from empty span node"), slate.Transforms.setNodes(
+            editor,
+            { marks: node.marks?.filter((mark) => decorators2.includes(mark)) },
+            { at: path }
           );
-          if (annotationMarks.length > 0) {
-            const [block] = slate.Editor.node(editor, slate.Path.parent(path)), orphanedMarks = editor.isTextBlock(block) && annotationMarks.filter(
-              (mark) => !block.markDefs?.find((def) => def._key === mark)
-            ) || [];
-            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;
-            }
-          }
+          return;
         }
-        for (const op of editor.operations) {
-          if (op.type === "merge_node" && op.path.length === 1 && "markDefs" in op.properties && op.properties._type === types2.block.name && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0 && op.path[0] - 1 >= 0) {
-            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]);
-              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) {
-            const [targetBlock, targetPath] = slate.Editor.node(editor, [op.path[0] + 1]);
-            if (debug$c("Copying markDefs over to split block", op), editor.isTextBlock(targetBlock)) {
-              const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [];
-              slate.Transforms.setNodes(
+      }
+      if (editor.isTextBlock(node)) {
+        const decorators2 = types2.decorators.map((decorator) => decorator.value);
+        for (const [child, childPath] of slate.Node.children(editor, path))
+          if (editor.isTextSpan(child)) {
+            const marks = child.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !node.markDefs?.find((def) => def._key === mark));
+            if (orphanedAnnotations.length > 0) {
+              debug$c("Removing orphaned annotations from span node"), slate.Transforms.setNodes(
                 editor,
-                { markDefs: uniq__default.default([...oldDefs, ...op.properties.markDefs]) },
-                { at: targetPath, voids: !1 }
+                { marks: marks.filter((mark) => !orphanedAnnotations.includes(mark)) },
+                { at: childPath }
               );
               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]);
-            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]]);
-            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;
-            }
+      }
+      if (editor.isTextSpan(node)) {
+        const blockPath = slate.Path.parent(path), [block] = slate.Editor.node(editor, blockPath);
+        if (editor.isTextBlock(block)) {
+          const decorators2 = types2.decorators.map((decorator) => decorator.value), marks = node.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
+          if (orphanedAnnotations.length > 0) {
+            debug$c("Removing orphaned annotations from span node"), slate.Transforms.setNodes(
+              editor,
+              { marks: marks.filter((mark) => !orphanedAnnotations.includes(mark)) },
+              { at: path }
+            );
+            return;
           }
         }
       }
@@ -2923,6 +2920,14 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
           }
         }
       }
+      if (op.type === "merge_node" && op.path.length === 1 && "markDefs" in op.properties && op.properties._type === types2.block.name && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0 && op.path[0] - 1 >= 0) {
+        const [targetBlock, targetPath] = slate.Editor.node(editor, [op.path[0] - 1]);
+        if (editor.isTextBlock(targetBlock)) {
+          const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [], newMarkDefs = uniq__default.default([...oldDefs, ...op.properties.markDefs]);
+          debug$c("Copying markDefs over to merged block", op), slate.Transforms.setNodes(editor, { markDefs: newMarkDefs }, { at: targetPath, voids: !1 }), apply2(op);
+          return;
+        }
+      }
       apply2(op);
     }, editor.addMark = (mark) => {
       if (editor.selection) {