@lexical/history 0.12.2 → 0.12.3

package/LexicalHistory.dev.js

@@ -18,213 +18,162 @@ 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),
-  // or after existing node.
-
+  }
 
+  // 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
-    // to run history logic again, as history entries already calculated
+    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
-      // due to some node transform reverting the change.
-
+      }
 
+      // 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'
@@ -232,27 +181,21 @@ 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, {
         tag: 'historic'
@@ -260,12 +203,12 @@ function undo(editor, historyState) {
     }
   }
 }
-
 function clearHistory(historyState) {
   historyState.undoStack = [];
   historyState.redoStack = [];
   historyState.current = null;
 }
+
 /**
  * Registers necessary listeners to manage undo/redo history stack and related editor commands.
  * It returns `unregister` callback that cleans up all listeners and should be called on editor unmount.
@@ -275,11 +218,8 @@ function clearHistory(historyState) {
  * instead of merging the current changes with the current stack.
  * @returns The listeners cleanup callback function.
  */
-
-
 function registerHistory(editor, historyState, delay) {
   const getMergeAction = createMergeActionGetter(editor, delay);
-
   const applyChange = ({
     editorState,
     prevEditorState,
@@ -291,35 +231,31 @@ 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
         });
         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;
@@ -341,11 +277,11 @@ function registerHistory(editor, historyState, delay) {
     unregisterUpdateListener();
   };
 }
+
 /**
  * Creates an empty history state.
  * @returns - The empty history state, as an object.
  */
-
 function createEmptyHistoryState() {
   return {
     current: null,

package/package.json

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