@portabletext/editor 1.0.13 → 1.0.14

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)) {
@@ -2806,6 +2832,14 @@ function createWithPortableTextMarkModel(types2, 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 && slate.Range.isCollapsed(selection) && slate.Editor.marks(editor)?.marks?.some((mark) => !decorators.includes(mark))) {
@@ -2846,15 +2880,23 @@ 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);
@@ -3821,10 +3863,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 +3914,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 +3950,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());
     });
   }
 }