@portabletext/editor 1.0.13 → 1.0.14

package/lib/index.esm.js

@@ -1299,55 +1299,85 @@ function createWithInsertBreak(types) {
     }, 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 (!Editor.isEditor(operation.node)) {
-          apply2({
-            ...operation,
-            node: {
-              ...operation.node,
-              ...withNewKey ? { _key: keyGenerator() } : {}
-            }
-          });
-          return;
-        }
+      if (operation.type === "insert_node" && !Editor.isEditor(operation.node)) {
+        apply2({
+          ...operation,
+          node: {
+            ...operation.node,
+            _key: keyGenerator()
+          }
+        });
+        return;
       }
       apply2(operation);
     }, editor.normalizeNode = (entry) => {
@@ -2237,16 +2267,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);
@@ -2327,7 +2347,7 @@ function createWithUndoRedo(options) {
           const reversedOperations = transformedOperations.map(Operation.inverse).reverse();
           try {
             Editor.withoutNormalizing(editor, () => {
-              withPreserveKeys(editor, () => {
+              withUndoing(editor, () => {
                 withoutSaving(editor, () => {
                   reversedOperations.forEach((op) => {
                     editor.apply(op);
@@ -2336,7 +2356,7 @@ function createWithUndoRedo(options) {
               });
             }), editor.normalize(), editor.onChange();
           } catch (err) {
-            debug$h("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), 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), 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();
@@ -2360,7 +2380,7 @@ function createWithUndoRedo(options) {
           });
           try {
             Editor.withoutNormalizing(editor, () => {
-              withPreserveKeys(editor, () => {
+              withRedoing(editor, () => {
                 withoutSaving(editor, () => {
                   transformedOperations.forEach((op) => {
                     editor.apply(op);
@@ -2369,7 +2389,7 @@ function createWithUndoRedo(options) {
               });
             }), editor.normalize(), editor.onChange();
           } catch (err) {
-            debug$h("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), 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), 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();
@@ -2483,10 +2503,8 @@ function createWithPatches({
         Editor.withoutNormalizing(editor, () => {
           withoutPatching(editor, () => {
             withoutSaving(editor, () => {
-              withPreserveKeys(editor, () => {
-                patches.forEach((patch) => {
-                  debug$g.enabled && debug$g(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
-                });
+              patches.forEach((patch) => {
+                debug$g.enabled && debug$g(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
               });
             });
           });
@@ -2583,6 +2601,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 && Editor.isVoid(editor, node)) {
@@ -2822,6 +2848,14 @@ function createWithPortableTextMarkModel(types, change$, keyGenerator) {
         ), editor.onChange());
       }
     }, 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 && Range.isCollapsed(selection) && Editor.marks(editor)?.marks?.some((mark) => !decorators.includes(mark))) {
@@ -2862,15 +2896,23 @@ function createWithPortableTextMarkModel(types, change$, keyGenerator) {
           ), deletingPartOfTheNode = op.offset !== 0, deletingFromTheEnd = op.offset + op.text.length === node.text.length;
           if (nodeHasAnnotations && deletingPartOfTheNode && deletingFromTheEnd) {
             Editor.withoutNormalizing(editor, () => {
-              withoutPreserveKeys(editor, () => {
-                Transforms.splitNodes(editor, {
-                  match: Text.isText,
-                  at: { path: op.path, offset: op.offset }
-                });
+              Transforms.splitNodes(editor, {
+                match: Text.isText,
+                at: { path: op.path, offset: op.offset }
               }), Transforms.removeNodes(editor, { at: Path.next(op.path) });
             }), editor.onChange();
             return;
           }
+          const deletingAllText = op.offset === 0 && deletingFromTheEnd;
+          if (nodeHasAnnotations && deletingAllText) {
+            const marksWithoutAnnotationMarks = ({
+              ...Editor.marks(editor) || {}
+            }.marks || []).filter((mark) => decorators.includes(mark));
+            Editor.withoutNormalizing(editor, () => {
+              apply2(op), Transforms.setNodes(editor, { marks: marksWithoutAnnotationMarks }, { at: op.path });
+            }), editor.onChange();
+            return;
+          }
         }
       }
       apply2(op);
@@ -3837,10 +3879,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, () => {
-                      Transforms.insertNodes(slateEditor, currentBlock, {
-                        at: [currentBlockIndex]
-                      });
+                    ), validation.valid || validation.resolution?.autoResolve ? Transforms.insertNodes(slateEditor, currentBlock, {
+                      at: [currentBlockIndex]
                     }) : (debug$5("Invalid", validation), change$.next({
                       type: "invalidValue",
                       resolution: validation.resolution,
@@ -3890,9 +3930,7 @@ function useSyncValue(props) {
 }
 function _replaceBlock(slateEditor, currentBlock, currentBlockIndex) {
   const currentSelection = slateEditor.selection, selectionFocusOnBlock = currentSelection && currentSelection.focus.path[0] === currentBlockIndex;
-  selectionFocusOnBlock && Transforms.deselect(slateEditor), Transforms.removeNodes(slateEditor, { at: [currentBlockIndex] }), withPreserveKeys(slateEditor, () => {
-    Transforms.insertNodes(slateEditor, currentBlock, { at: [currentBlockIndex] });
-  }), slateEditor.onChange(), selectionFocusOnBlock && Transforms.select(slateEditor, currentSelection);
+  selectionFocusOnBlock && Transforms.deselect(slateEditor), Transforms.removeNodes(slateEditor, { at: [currentBlockIndex] }), Transforms.insertNodes(slateEditor, currentBlock, { at: [currentBlockIndex] }), slateEditor.onChange(), selectionFocusOnBlock && Transforms.select(slateEditor, currentSelection);
 }
 function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
   if (Transforms.setNodes(slateEditor, currentBlock, {
@@ -3928,15 +3966,11 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
           ));
         } else oldBlockChild ? (debug$5("Replacing child", currentBlockChild), Transforms.removeNodes(slateEditor, {
           at: [currentBlockIndex, currentBlockChildIndex]
-        }), withPreserveKeys(slateEditor, () => {
-          Transforms.insertNodes(slateEditor, currentBlockChild, {
-            at: [currentBlockIndex, currentBlockChildIndex]
-          });
-        }), slateEditor.onChange()) : oldBlockChild || (debug$5("Inserting new child", currentBlockChild), withPreserveKeys(slateEditor, () => {
-          Transforms.insertNodes(slateEditor, currentBlockChild, {
-            at: [currentBlockIndex, currentBlockChildIndex]
-          }), slateEditor.onChange();
-        }));
+        }), Transforms.insertNodes(slateEditor, currentBlockChild, {
+          at: [currentBlockIndex, currentBlockChildIndex]
+        }), slateEditor.onChange()) : oldBlockChild || (debug$5("Inserting new child", currentBlockChild), Transforms.insertNodes(slateEditor, currentBlockChild, {
+          at: [currentBlockIndex, currentBlockChildIndex]
+        }), slateEditor.onChange());
     });
   }
 }