@lexical/history 0.8.1 → 0.9.1

package/LexicalHistory.dev.js

@@ -18,162 +18,213 @@ const COMPOSING_CHARACTER = 1;
 const INSERT_CHARACTER_AFTER_SELECTION = 2;
 const DELETE_CHARACTER_BEFORE_SELECTION = 3;
 const DELETE_CHARACTER_AFTER_SELECTION = 4;
+
 function getDirtyNodes(editorState, dirtyLeaves, dirtyElements) {
   const nodeMap = editorState._nodeMap;
   const nodes = [];
+
   for (const dirtyLeafKey of dirtyLeaves) {
     const dirtyLeaf = nodeMap.get(dirtyLeafKey);
+
     if (dirtyLeaf !== undefined) {
       nodes.push(dirtyLeaf);
     }
   }
+
   for (const [dirtyElementKey, intentionallyMarkedAsDirty] of dirtyElements) {
     if (!intentionallyMarkedAsDirty) {
       continue;
     }
+
     const dirtyElement = nodeMap.get(dirtyElementKey);
+
     if (dirtyElement !== undefined && !lexical.$isRootNode(dirtyElement)) {
       nodes.push(dirtyElement);
     }
   }
+
   return nodes;
 }
+
 function getChangeType(prevEditorState, nextEditorState, dirtyLeavesSet, dirtyElementsSet, isComposing) {
   if (prevEditorState === null || dirtyLeavesSet.size === 0 && dirtyElementsSet.size === 0 && !isComposing) {
     return OTHER;
   }
+
   const nextSelection = nextEditorState._selection;
   const prevSelection = prevEditorState._selection;
+
   if (isComposing) {
     return COMPOSING_CHARACTER;
   }
+
   if (!lexical.$isRangeSelection(nextSelection) || !lexical.$isRangeSelection(prevSelection) || !prevSelection.isCollapsed() || !nextSelection.isCollapsed()) {
     return OTHER;
   }
+
   const dirtyNodes = getDirtyNodes(nextEditorState, dirtyLeavesSet, dirtyElementsSet);
+
   if (dirtyNodes.length === 0) {
     return OTHER;
-  }
-
-  // Catching the case when inserting new text node into an element (e.g. first char in paragraph/list),
+  } // Catching the case when inserting new text node into an element (e.g. first char in paragraph/list),
   // or after existing node.
+
+
   if (dirtyNodes.length > 1) {
     const nextNodeMap = nextEditorState._nodeMap;
     const nextAnchorNode = nextNodeMap.get(nextSelection.anchor.key);
     const prevAnchorNode = nextNodeMap.get(prevSelection.anchor.key);
+
     if (nextAnchorNode && prevAnchorNode && !prevEditorState._nodeMap.has(nextAnchorNode.__key) && lexical.$isTextNode(nextAnchorNode) && nextAnchorNode.__text.length === 1 && nextSelection.anchor.offset === 1) {
       return INSERT_CHARACTER_AFTER_SELECTION;
     }
+
     return OTHER;
   }
+
   const nextDirtyNode = dirtyNodes[0];
+
   const prevDirtyNode = prevEditorState._nodeMap.get(nextDirtyNode.__key);
+
   if (!lexical.$isTextNode(prevDirtyNode) || !lexical.$isTextNode(nextDirtyNode) || prevDirtyNode.__mode !== nextDirtyNode.__mode) {
     return OTHER;
   }
+
   const prevText = prevDirtyNode.__text;
   const nextText = nextDirtyNode.__text;
+
   if (prevText === nextText) {
     return OTHER;
   }
+
   const nextAnchor = nextSelection.anchor;
   const prevAnchor = prevSelection.anchor;
+
   if (nextAnchor.key !== prevAnchor.key || nextAnchor.type !== 'text') {
     return OTHER;
   }
+
   const nextAnchorOffset = nextAnchor.offset;
   const prevAnchorOffset = prevAnchor.offset;
   const textDiff = nextText.length - prevText.length;
+
   if (textDiff === 1 && prevAnchorOffset === nextAnchorOffset - 1) {
     return INSERT_CHARACTER_AFTER_SELECTION;
   }
+
   if (textDiff === -1 && prevAnchorOffset === nextAnchorOffset + 1) {
     return DELETE_CHARACTER_BEFORE_SELECTION;
   }
+
   if (textDiff === -1 && prevAnchorOffset === nextAnchorOffset) {
     return DELETE_CHARACTER_AFTER_SELECTION;
   }
+
   return OTHER;
 }
+
 function isTextNodeUnchanged(key, prevEditorState, nextEditorState) {
   const prevNode = prevEditorState._nodeMap.get(key);
+
   const nextNode = nextEditorState._nodeMap.get(key);
+
   const prevSelection = prevEditorState._selection;
   const nextSelection = nextEditorState._selection;
   let isDeletingLine = false;
+
   if (lexical.$isRangeSelection(prevSelection) && lexical.$isRangeSelection(nextSelection)) {
     isDeletingLine = prevSelection.anchor.type === 'element' && prevSelection.focus.type === 'element' && nextSelection.anchor.type === 'text' && nextSelection.focus.type === 'text';
   }
+
   if (!isDeletingLine && lexical.$isTextNode(prevNode) && lexical.$isTextNode(nextNode)) {
     return prevNode.__type === nextNode.__type && prevNode.__text === nextNode.__text && prevNode.__mode === nextNode.__mode && prevNode.__detail === nextNode.__detail && prevNode.__style === nextNode.__style && prevNode.__format === nextNode.__format && prevNode.__parent === nextNode.__parent;
   }
+
   return false;
 }
+
 function createMergeActionGetter(editor, delay) {
   let prevChangeTime = Date.now();
   let prevChangeType = OTHER;
   return (prevEditorState, nextEditorState, currentHistoryEntry, dirtyLeaves, dirtyElements, tags) => {
-    const changeTime = Date.now();
-
-    // If applying changes from history stack there's no need
+    const changeTime = Date.now(); // If applying changes from history stack there's no need
     // to run history logic again, as history entries already calculated
+
     if (tags.has('historic')) {
       prevChangeType = OTHER;
       prevChangeTime = changeTime;
       return DISCARD_HISTORY_CANDIDATE;
     }
+
     const changeType = getChangeType(prevEditorState, nextEditorState, dirtyLeaves, dirtyElements, editor.isComposing());
+
     const mergeAction = (() => {
       const isSameEditor = currentHistoryEntry === null || currentHistoryEntry.editor === editor;
       const shouldPushHistory = tags.has('history-push');
       const shouldMergeHistory = !shouldPushHistory && isSameEditor && tags.has('history-merge');
+
       if (shouldMergeHistory) {
         return HISTORY_MERGE;
       }
+
       if (prevEditorState === null) {
         return HISTORY_PUSH;
       }
+
       const selection = nextEditorState._selection;
       const hasDirtyNodes = dirtyLeaves.size > 0 || dirtyElements.size > 0;
+
       if (!hasDirtyNodes) {
         if (selection !== null) {
           return HISTORY_MERGE;
         }
+
         return DISCARD_HISTORY_CANDIDATE;
       }
+
       if (shouldPushHistory === false && changeType !== OTHER && changeType === prevChangeType && changeTime < prevChangeTime + delay && isSameEditor) {
         return HISTORY_MERGE;
-      }
-
-      // A single node might have been marked as dirty, but not have changed
+      } // A single node might have been marked as dirty, but not have changed
       // due to some node transform reverting the change.
+
+
       if (dirtyLeaves.size === 1) {
         const dirtyLeafKey = Array.from(dirtyLeaves)[0];
+
         if (isTextNodeUnchanged(dirtyLeafKey, prevEditorState, nextEditorState)) {
           return HISTORY_MERGE;
         }
       }
+
       return HISTORY_PUSH;
     })();
+
     prevChangeTime = changeTime;
     prevChangeType = changeType;
     return mergeAction;
   };
 }
+
 function redo(editor, historyState) {
   const redoStack = historyState.redoStack;
   const undoStack = historyState.undoStack;
+
   if (redoStack.length !== 0) {
     const current = historyState.current;
+
     if (current !== null) {
       undoStack.push(current);
       editor.dispatchCommand(lexical.CAN_UNDO_COMMAND, true);
     }
+
     const historyStateEntry = redoStack.pop();
+
     if (redoStack.length === 0) {
       editor.dispatchCommand(lexical.CAN_REDO_COMMAND, false);
     }
+
     historyState.current = historyStateEntry || null;
+
     if (historyStateEntry) {
       historyStateEntry.editor.setEditorState(historyStateEntry.editorState, {
         tag: 'historic'
@@ -181,21 +232,27 @@ function redo(editor, historyState) {
     }
   }
 }
+
 function undo(editor, historyState) {
   const redoStack = historyState.redoStack;
   const undoStack = historyState.undoStack;
   const undoStackLength = undoStack.length;
+
   if (undoStackLength !== 0) {
     const current = historyState.current;
     const historyStateEntry = undoStack.pop();
+
     if (current !== null) {
       redoStack.push(current);
       editor.dispatchCommand(lexical.CAN_REDO_COMMAND, true);
     }
+
     if (undoStack.length === 0) {
       editor.dispatchCommand(lexical.CAN_UNDO_COMMAND, false);
     }
+
     historyState.current = historyStateEntry || null;
+
     if (historyStateEntry) {
       historyStateEntry.editor.setEditorState(historyStateEntry.editorState.clone(historyStateEntry.undoSelection), {
         tag: 'historic'
@@ -203,13 +260,16 @@ function undo(editor, historyState) {
     }
   }
 }
+
 function clearHistory(historyState) {
   historyState.undoStack = [];
   historyState.redoStack = [];
   historyState.current = null;
 }
+
 function registerHistory(editor, historyState, delay) {
   const getMergeAction = createMergeActionGetter(editor, delay);
+
   const applyChange = ({
     editorState,
     prevEditorState,
@@ -221,31 +281,36 @@ function registerHistory(editor, historyState, delay) {
     const redoStack = historyState.redoStack;
     const undoStack = historyState.undoStack;
     const currentEditorState = current === null ? null : current.editorState;
+
     if (current !== null && editorState === currentEditorState) {
       return;
     }
+
     const mergeAction = getMergeAction(prevEditorState, editorState, current, dirtyLeaves, dirtyElements, tags);
+
     if (mergeAction === HISTORY_PUSH) {
       if (redoStack.length !== 0) {
         historyState.redoStack = [];
+        editor.dispatchCommand(lexical.CAN_REDO_COMMAND, false);
       }
+
       if (current !== null) {
-        undoStack.push({
-          ...current,
+        undoStack.push({ ...current,
           undoSelection: prevEditorState.read(lexical.$getSelection)
         });
         editor.dispatchCommand(lexical.CAN_UNDO_COMMAND, true);
       }
     } else if (mergeAction === DISCARD_HISTORY_CANDIDATE) {
       return;
-    }
+    } // Else we merge
+
 
-    // Else we merge
     historyState.current = {
       editor,
       editorState
     };
   };
+
   const unregisterCommandListener = utils.mergeRegister(editor.registerCommand(lexical.UNDO_COMMAND, () => {
     undo(editor, historyState);
     return true;

package/LexicalHistory.prod.js

@@ -9,7 +9,7 @@ function y(b,a,m,k,p){if(null===b||0===m.size&&0===k.size&&!p)return 0;var f=a._
 1===a.__text.length&&1===f.anchor.offset?2:0;a=e[0];b=b._nodeMap.get(a.__key);if(!x.$isTextNode(b)||!x.$isTextNode(a)||b.__mode!==a.__mode)return 0;b=b.__text;a=a.__text;if(b===a)return 0;f=f.anchor;d=d.anchor;if(f.key!==d.key||"text"!==f.type)return 0;f=f.offset;d=d.offset;b=a.length-b.length;return 1===b&&d===f-1?2:-1===b&&d===f+1?3:-1===b&&d===f?4:0}
 function z(b,a){let m=Date.now(),k=0;return(p,f,d,e,g,n)=>{let r=Date.now();if(n.has("historic"))return k=0,m=r,2;let q=y(p,f,e,g,b.isComposing()),v=(()=>{var l=null===d||d.editor===b,h=n.has("history-push");if(!h&&l&&n.has("history-merge"))return 0;if(null===p)return 1;var t=f._selection;if(!(0<e.size||0<g.size))return null!==t?0:2;if(!1===h&&0!==q&&q===k&&r<m+a&&l)return 0;if(1===e.size){{h=Array.from(e)[0];l=p._nodeMap.get(h);h=f._nodeMap.get(h);t=p._selection;let u=f._selection,w=!1;x.$isRangeSelection(t)&&
 x.$isRangeSelection(u)&&(w="element"===t.anchor.type&&"element"===t.focus.type&&"text"===u.anchor.type&&"text"===u.focus.type);l=!w&&x.$isTextNode(l)&&x.$isTextNode(h)?l.__type===h.__type&&l.__text===h.__text&&l.__mode===h.__mode&&l.__detail===h.__detail&&l.__style===h.__style&&l.__format===h.__format&&l.__parent===h.__parent:!1}if(l)return 0}return 1})();m=r;k=q;return v}}exports.createEmptyHistoryState=function(){return{current:null,redoStack:[],undoStack:[]}};
-exports.registerHistory=function(b,a,m){let k=z(b,m);m=({editorState:d,prevEditorState:e,dirtyLeaves:g,dirtyElements:n,tags:r})=>{const q=a.current,v=a.redoStack,l=a.undoStack,h=null===q?null:q.editorState;if(null===q||d!==h){g=k(e,d,q,g,n,r);if(1===g)0!==v.length&&(a.redoStack=[]),null!==q&&(l.push({...q,undoSelection:e.read(x.$getSelection)}),b.dispatchCommand(x.CAN_UNDO_COMMAND,!0));else if(2===g)return;a.current={editor:b,editorState:d}}};let p=c.mergeRegister(b.registerCommand(x.UNDO_COMMAND,
+exports.registerHistory=function(b,a,m){let k=z(b,m);m=({editorState:d,prevEditorState:e,dirtyLeaves:g,dirtyElements:n,tags:r})=>{const q=a.current,v=a.redoStack,l=a.undoStack,h=null===q?null:q.editorState;if(null===q||d!==h){g=k(e,d,q,g,n,r);if(1===g)0!==v.length&&(a.redoStack=[],b.dispatchCommand(x.CAN_REDO_COMMAND,!1)),null!==q&&(l.push({...q,undoSelection:e.read(x.$getSelection)}),b.dispatchCommand(x.CAN_UNDO_COMMAND,!0));else if(2===g)return;a.current={editor:b,editorState:d}}};let p=c.mergeRegister(b.registerCommand(x.UNDO_COMMAND,
 ()=>{let d=a.redoStack,e=a.undoStack;if(0!==e.length){let g=a.current,n=e.pop();null!==g&&(d.push(g),b.dispatchCommand(x.CAN_REDO_COMMAND,!0));0===e.length&&b.dispatchCommand(x.CAN_UNDO_COMMAND,!1);a.current=n||null;n&&n.editor.setEditorState(n.editorState.clone(n.undoSelection),{tag:"historic"})}return!0},x.COMMAND_PRIORITY_EDITOR),b.registerCommand(x.REDO_COMMAND,()=>{let d=a.redoStack;var e=a.undoStack;if(0!==d.length){let g=a.current;null!==g&&(e.push(g),b.dispatchCommand(x.CAN_UNDO_COMMAND,!0));
 e=d.pop();0===d.length&&b.dispatchCommand(x.CAN_REDO_COMMAND,!1);a.current=e||null;e&&e.editor.setEditorState(e.editorState,{tag:"historic"})}return!0},x.COMMAND_PRIORITY_EDITOR),b.registerCommand(x.CLEAR_EDITOR_COMMAND,()=>{a.undoStack=[];a.redoStack=[];a.current=null;return!1},x.COMMAND_PRIORITY_EDITOR),b.registerCommand(x.CLEAR_HISTORY_COMMAND,()=>{a.undoStack=[];a.redoStack=[];a.current=null;b.dispatchCommand(x.CAN_REDO_COMMAND,!1);b.dispatchCommand(x.CAN_UNDO_COMMAND,!1);return!0},x.COMMAND_PRIORITY_EDITOR),
 b.registerUpdateListener(m)),f=b.registerUpdateListener(m);return()=>{p();f()}}

package/package.json

@@ -8,13 +8,13 @@
     "history"
   ],
   "license": "MIT",
-  "version": "0.8.1",
+  "version": "0.9.1",
   "main": "LexicalHistory.js",
   "peerDependencies": {
-    "lexical": "0.8.1"
+    "lexical": "0.9.1"
   },
   "dependencies": {
-    "@lexical/utils": "0.8.1"
+    "@lexical/utils": "0.9.1"
   },
   "repository": {
     "type": "git",