@portabletext/editor 1.0.18 → 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);
@@ -1152,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,
@@ -2770,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) {
@@ -2785,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;
           }
         }
       }
@@ -2937,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) {