@portabletext/editor 1.0.13 → 1.0.15

package/lib/index.js

@@ -1283,55 +1283,85 @@ function createWithInsertBreak(types2) {
     }, editor;
   };
 }
+function withRemoteChanges(editor, fn) {
+  const prev = isChangingRemotely(editor) || !1;
+  IS_PROCESSING_REMOTE_CHANGES.set(editor, !0), fn(), IS_PROCESSING_REMOTE_CHANGES.set(editor, prev);
+}
+function isChangingRemotely(editor) {
+  return IS_PROCESSING_REMOTE_CHANGES.get(editor);
+}
+function isChangingLocally(editor) {
+  return IS_PROCESSING_LOCAL_CHANGES.get(editor);
+}
+const IS_UDOING = /* @__PURE__ */ new WeakMap(), IS_REDOING = /* @__PURE__ */ new WeakMap();
+function withUndoing(editor, fn) {
+  const prev = isUndoing(editor);
+  IS_UDOING.set(editor, !0), fn(), IS_UDOING.set(editor, prev);
+}
+function isUndoing(editor) {
+  return IS_UDOING.get(editor) ?? !1;
+}
+function setIsUndoing(editor, isUndoing2) {
+  IS_UDOING.set(editor, isUndoing2);
+}
+function withRedoing(editor, fn) {
+  const prev = isRedoing(editor);
+  IS_REDOING.set(editor, !0), fn(), IS_REDOING.set(editor, prev);
+}
+function isRedoing(editor) {
+  return IS_REDOING.get(editor) ?? !1;
+}
+function setIsRedoing(editor, isRedoing2) {
+  IS_REDOING.set(editor, isRedoing2);
+}
 function createWithMaxBlocks(maxBlocks) {
   return function(editor) {
     const { apply: apply2 } = editor;
     return editor.apply = (operation) => {
+      if (isChangingRemotely(editor)) {
+        apply2(operation);
+        return;
+      }
+      if (isUndoing(editor) || isRedoing(editor)) {
+        apply2(operation);
+        return;
+      }
       const rows = maxBlocks;
       rows > 0 && editor.children.length >= rows && (operation.type === "insert_node" || operation.type === "split_node") && operation.path.length === 1 || apply2(operation);
     }, editor;
   };
 }
-const PRESERVE_KEYS = /* @__PURE__ */ new WeakMap();
-function withPreserveKeys(editor, fn) {
-  const prev = isPreservingKeys(editor);
-  PRESERVE_KEYS.set(editor, !0), fn(), PRESERVE_KEYS.set(editor, prev);
-}
-function withoutPreserveKeys(editor, fn) {
-  const prev = isPreservingKeys(editor);
-  PRESERVE_KEYS.set(editor, !1), fn(), PRESERVE_KEYS.set(editor, prev);
-}
-function isPreservingKeys(editor) {
-  return PRESERVE_KEYS.get(editor);
-}
 function createWithObjectKeys(schemaTypes, keyGenerator) {
   return function(editor) {
-    PRESERVE_KEYS.set(editor, !1);
     const { apply: apply2, normalizeNode } = editor;
     return editor.apply = (operation) => {
+      if (isChangingRemotely(editor)) {
+        apply2(operation);
+        return;
+      }
+      if (isUndoing(editor) || isRedoing(editor)) {
+        apply2(operation);
+        return;
+      }
       if (operation.type === "split_node") {
-        const withNewKey = !isPreservingKeys(editor) || !("_key" in operation.properties);
         apply2({
           ...operation,
           properties: {
             ...operation.properties,
-            ...withNewKey ? { _key: keyGenerator() } : {}
+            _key: keyGenerator()
           }
         });
         return;
       }
-      if (operation.type === "insert_node") {
-        const withNewKey = !isPreservingKeys(editor) || !("_key" in operation.node);
-        if (!slate.Editor.isEditor(operation.node)) {
-          apply2({
-            ...operation,
-            node: {
-              ...operation.node,
-              ...withNewKey ? { _key: keyGenerator() } : {}
-            }
-          });
-          return;
-        }
+      if (operation.type === "insert_node" && !slate.Editor.isEditor(operation.node)) {
+        apply2({
+          ...operation,
+          node: {
+            ...operation.node,
+            _key: keyGenerator()
+          }
+        });
+        return;
       }
       apply2(operation);
     }, editor.normalizeNode = (entry) => {
@@ -2221,16 +2251,6 @@ function findBlockAndChildFromPath(editor, path) {
   });
   return child ? { block, child, blockPath, childPath: blockPath?.concat(childIndex) } : { block, blockPath, child: void 0, childPath: void 0 };
 }
-function withRemoteChanges(editor, fn) {
-  const prev = isChangingRemotely(editor) || !1;
-  IS_PROCESSING_REMOTE_CHANGES.set(editor, !0), fn(), IS_PROCESSING_REMOTE_CHANGES.set(editor, prev);
-}
-function isChangingRemotely(editor) {
-  return IS_PROCESSING_REMOTE_CHANGES.get(editor);
-}
-function isChangingLocally(editor) {
-  return IS_PROCESSING_LOCAL_CHANGES.get(editor);
-}
 const PATCHING = /* @__PURE__ */ new WeakMap();
 function withoutPatching(editor, fn) {
   const prev = isPatching(editor);
@@ -2311,7 +2331,7 @@ function createWithUndoRedo(options) {
           const reversedOperations = transformedOperations.map(slate.Operation.inverse).reverse();
           try {
             slate.Editor.withoutNormalizing(editor, () => {
-              withPreserveKeys(editor, () => {
+              withUndoing(editor, () => {
                 withoutSaving(editor, () => {
                   reversedOperations.forEach((op) => {
                     editor.apply(op);
@@ -2320,7 +2340,7 @@ function createWithUndoRedo(options) {
               });
             }), editor.normalize(), editor.onChange();
           } catch (err) {
-            debug$h("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = { undos: [], redos: [] }, SAVING.set(editor, !0), editor.onChange();
+            debug$h("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = { undos: [], redos: [] }, SAVING.set(editor, !0), setIsUndoing(editor, !1), editor.onChange();
             return;
           }
           editor.history.redos.push(step), editor.history.undos.pop();
@@ -2344,7 +2364,7 @@ function createWithUndoRedo(options) {
           });
           try {
             slate.Editor.withoutNormalizing(editor, () => {
-              withPreserveKeys(editor, () => {
+              withRedoing(editor, () => {
                 withoutSaving(editor, () => {
                   transformedOperations.forEach((op) => {
                     editor.apply(op);
@@ -2353,7 +2373,7 @@ function createWithUndoRedo(options) {
               });
             }), editor.normalize(), editor.onChange();
           } catch (err) {
-            debug$h("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = { undos: [], redos: [] }, SAVING.set(editor, !0), editor.onChange();
+            debug$h("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = { undos: [], redos: [] }, SAVING.set(editor, !0), setIsRedoing(editor, !1), editor.onChange();
             return;
           }
           editor.history.undos.push(step), editor.history.redos.pop();
@@ -2467,10 +2487,8 @@ function createWithPatches({
         slate.Editor.withoutNormalizing(editor, () => {
           withoutPatching(editor, () => {
             withoutSaving(editor, () => {
-              withPreserveKeys(editor, () => {
-                patches2.forEach((patch) => {
-                  debug$g.enabled && debug$g(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
-                });
+              patches2.forEach((patch) => {
+                debug$g.enabled && debug$g(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
               });
             });
           });
@@ -2567,6 +2585,14 @@ function createWithPlaceholderBlock() {
   return function(editor) {
     const { apply: apply2 } = editor;
     return editor.apply = (op) => {
+      if (isChangingRemotely(editor)) {
+        apply2(op);
+        return;
+      }
+      if (isUndoing(editor) || isRedoing(editor)) {
+        apply2(op);
+        return;
+      }
       if (op.type === "remove_node") {
         const node = op.node;
         if (op.path[0] === 0 && slate.Editor.isVoid(editor, node)) {
@@ -2736,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)
           );
@@ -2756,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) {
@@ -2768,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) {
@@ -2779,33 +2819,55 @@ 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);
+        return;
+      }
+      if (isUndoing(editor) || isRedoing(editor)) {
+        apply2(op);
+        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))) {
@@ -2846,29 +2908,33 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
           ), deletingPartOfTheNode = op.offset !== 0, deletingFromTheEnd = op.offset + op.text.length === node.text.length;
           if (nodeHasAnnotations && deletingPartOfTheNode && deletingFromTheEnd) {
             slate.Editor.withoutNormalizing(editor, () => {
-              withoutPreserveKeys(editor, () => {
-                slate.Transforms.splitNodes(editor, {
-                  match: slate.Text.isText,
-                  at: { path: op.path, offset: op.offset }
-                });
+              slate.Transforms.splitNodes(editor, {
+                match: slate.Text.isText,
+                at: { path: op.path, offset: op.offset }
               }), slate.Transforms.removeNodes(editor, { at: slate.Path.next(op.path) });
             }), editor.onChange();
             return;
           }
+          const deletingAllText = op.offset === 0 && deletingFromTheEnd;
+          if (nodeHasAnnotations && deletingAllText) {
+            const marksWithoutAnnotationMarks = ({
+              ...slate.Editor.marks(editor) || {}
+            }.marks || []).filter((mark) => decorators.includes(mark));
+            slate.Editor.withoutNormalizing(editor, () => {
+              apply2(op), slate.Transforms.setNodes(editor, { marks: marksWithoutAnnotationMarks }, { at: op.path });
+            }), editor.onChange();
+            return;
+          }
         }
       }
       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
@@ -2881,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 = {
@@ -2943,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) {
@@ -3821,10 +3868,8 @@ function useSyncValue(props) {
                     debug$5.enabled && debug$5(
                       "Validating and inserting new block in the end of the value",
                       currentBlock
-                    ), validation.valid || validation.resolution?.autoResolve ? withPreserveKeys(slateEditor, () => {
-                      slate.Transforms.insertNodes(slateEditor, currentBlock, {
-                        at: [currentBlockIndex]
-                      });
+                    ), validation.valid || validation.resolution?.autoResolve ? slate.Transforms.insertNodes(slateEditor, currentBlock, {
+                      at: [currentBlockIndex]
                     }) : (debug$5("Invalid", validation), change$.next({
                       type: "invalidValue",
                       resolution: validation.resolution,
@@ -3874,9 +3919,7 @@ function useSyncValue(props) {
 }
 function _replaceBlock(slateEditor, currentBlock, currentBlockIndex) {
   const currentSelection = slateEditor.selection, selectionFocusOnBlock = currentSelection && currentSelection.focus.path[0] === currentBlockIndex;
-  selectionFocusOnBlock && slate.Transforms.deselect(slateEditor), slate.Transforms.removeNodes(slateEditor, { at: [currentBlockIndex] }), withPreserveKeys(slateEditor, () => {
-    slate.Transforms.insertNodes(slateEditor, currentBlock, { at: [currentBlockIndex] });
-  }), slateEditor.onChange(), selectionFocusOnBlock && slate.Transforms.select(slateEditor, currentSelection);
+  selectionFocusOnBlock && slate.Transforms.deselect(slateEditor), slate.Transforms.removeNodes(slateEditor, { at: [currentBlockIndex] }), slate.Transforms.insertNodes(slateEditor, currentBlock, { at: [currentBlockIndex] }), slateEditor.onChange(), selectionFocusOnBlock && slate.Transforms.select(slateEditor, currentSelection);
 }
 function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
   if (slate.Transforms.setNodes(slateEditor, currentBlock, {
@@ -3912,15 +3955,11 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
           ));
         } else oldBlockChild ? (debug$5("Replacing child", currentBlockChild), slate.Transforms.removeNodes(slateEditor, {
           at: [currentBlockIndex, currentBlockChildIndex]
-        }), withPreserveKeys(slateEditor, () => {
-          slate.Transforms.insertNodes(slateEditor, currentBlockChild, {
-            at: [currentBlockIndex, currentBlockChildIndex]
-          });
-        }), slateEditor.onChange()) : oldBlockChild || (debug$5("Inserting new child", currentBlockChild), withPreserveKeys(slateEditor, () => {
-          slate.Transforms.insertNodes(slateEditor, currentBlockChild, {
-            at: [currentBlockIndex, currentBlockChildIndex]
-          }), slateEditor.onChange();
-        }));
+        }), slate.Transforms.insertNodes(slateEditor, currentBlockChild, {
+          at: [currentBlockIndex, currentBlockChildIndex]
+        }), slateEditor.onChange()) : oldBlockChild || (debug$5("Inserting new child", currentBlockChild), slate.Transforms.insertNodes(slateEditor, currentBlockChild, {
+          at: [currentBlockIndex, currentBlockChildIndex]
+        }), slateEditor.onChange());
     });
   }
 }