@lexical/history 0.14.0 → 0.14.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/{src/index.ts → LexicalHistory.dev.esm.js}

@@ -1,119 +1,54 @@
-/** @module @lexical/history */
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
- *
  */
+import { mergeRegister } from '@lexical/utils';
+import { UNDO_COMMAND, COMMAND_PRIORITY_EDITOR, REDO_COMMAND, CLEAR_EDITOR_COMMAND, CLEAR_HISTORY_COMMAND, CAN_REDO_COMMAND, CAN_UNDO_COMMAND, $isRangeSelection, $isTextNode, $isRootNode } from 'lexical';
 
-import type {EditorState, LexicalEditor, LexicalNode, NodeKey} from 'lexical';
-
-import {mergeRegister} from '@lexical/utils';
-import {
-  $isRangeSelection,
-  $isRootNode,
-  $isTextNode,
-  CAN_REDO_COMMAND,
-  CAN_UNDO_COMMAND,
-  CLEAR_EDITOR_COMMAND,
-  CLEAR_HISTORY_COMMAND,
-  COMMAND_PRIORITY_EDITOR,
-  REDO_COMMAND,
-  UNDO_COMMAND,
-} from 'lexical';
-
-type MergeAction = 0 | 1 | 2;
+/** @module @lexical/history */
 const HISTORY_MERGE = 0;
 const HISTORY_PUSH = 1;
 const DISCARD_HISTORY_CANDIDATE = 2;
-
-type ChangeType = 0 | 1 | 2 | 3 | 4;
 const OTHER = 0;
 const COMPOSING_CHARACTER = 1;
 const INSERT_CHARACTER_AFTER_SELECTION = 2;
 const DELETE_CHARACTER_BEFORE_SELECTION = 3;
 const DELETE_CHARACTER_AFTER_SELECTION = 4;
-
-export type HistoryStateEntry = {
-  editor: LexicalEditor;
-  editorState: EditorState;
-};
-export type HistoryState = {
-  current: null | HistoryStateEntry;
-  redoStack: Array<HistoryStateEntry>;
-  undoStack: Array<HistoryStateEntry>;
-};
-
-type IntentionallyMarkedAsDirtyElement = boolean;
-
-function getDirtyNodes(
-  editorState: EditorState,
-  dirtyLeaves: Set<NodeKey>,
-  dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>,
-): Array<LexicalNode> {
+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 && !$isRootNode(dirtyElement)) {
       nodes.push(dirtyElement);
     }
   }
-
   return nodes;
 }
-
-function getChangeType(
-  prevEditorState: null | EditorState,
-  nextEditorState: EditorState,
-  dirtyLeavesSet: Set<NodeKey>,
-  dirtyElementsSet: Map<NodeKey, IntentionallyMarkedAsDirtyElement>,
-  isComposing: boolean,
-): ChangeType {
-  if (
-    prevEditorState === null ||
-    (dirtyLeavesSet.size === 0 && dirtyElementsSet.size === 0 && !isComposing)
-  ) {
+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 (
-    !$isRangeSelection(nextSelection) ||
-    !$isRangeSelection(prevSelection) ||
-    !prevSelection.isCollapsed() ||
-    !nextSelection.isCollapsed()
-  ) {
+  if (!$isRangeSelection(nextSelection) || !$isRangeSelection(prevSelection) || !prevSelection.isCollapsed() || !nextSelection.isCollapsed()) {
     return OTHER;
   }
-
-  const dirtyNodes = getDirtyNodes(
-    nextEditorState,
-    dirtyLeavesSet,
-    dirtyElementsSet,
-  );
-
+  const dirtyNodes = getDirtyNodes(nextEditorState, dirtyLeavesSet, dirtyElementsSet);
   if (dirtyNodes.length === 0) {
     return OTHER;
   }
@@ -124,122 +59,58 @@ function getChangeType(
     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) &&
-      $isTextNode(nextAnchorNode) &&
-      nextAnchorNode.__text.length === 1 &&
-      nextSelection.anchor.offset === 1
-    ) {
+    if (nextAnchorNode && prevAnchorNode && !prevEditorState._nodeMap.has(nextAnchorNode.__key) && $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 (
-    !$isTextNode(prevDirtyNode) ||
-    !$isTextNode(nextDirtyNode) ||
-    prevDirtyNode.__mode !== nextDirtyNode.__mode
-  ) {
+  if (!$isTextNode(prevDirtyNode) || !$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: NodeKey,
-  prevEditorState: EditorState,
-  nextEditorState: EditorState,
-): boolean {
+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 ($isRangeSelection(prevSelection) && $isRangeSelection(nextSelection)) {
-    isDeletingLine =
-      prevSelection.anchor.type === 'element' &&
-      prevSelection.focus.type === 'element' &&
-      nextSelection.anchor.type === 'text' &&
-      nextSelection.focus.type === 'text';
+    isDeletingLine = prevSelection.anchor.type === 'element' && prevSelection.focus.type === 'element' && nextSelection.anchor.type === 'text' && nextSelection.focus.type === 'text';
   }
-
   if (!isDeletingLine && $isTextNode(prevNode) && $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 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: LexicalEditor,
-  delay: number,
-): (
-  prevEditorState: null | EditorState,
-  nextEditorState: EditorState,
-  currentHistoryEntry: null | HistoryStateEntry,
-  dirtyLeaves: Set<NodeKey>,
-  dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>,
-  tags: Set<string>,
-) => MergeAction {
+function createMergeActionGetter(editor, delay) {
   let prevChangeTime = Date.now();
   let prevChangeType = OTHER;
-
-  return (
-    prevEditorState,
-    nextEditorState,
-    currentHistoryEntry,
-    dirtyLeaves,
-    dirtyElements,
-    tags,
-  ) => {
+  return (prevEditorState, nextEditorState, currentHistoryEntry, dirtyLeaves, dirtyElements, tags) => {
     const changeTime = Date.now();
 
     // If applying changes from history stack there's no need
@@ -249,48 +120,26 @@ function createMergeActionGetter(
       prevChangeTime = changeTime;
       return DISCARD_HISTORY_CANDIDATE;
     }
-
-    const changeType = getChangeType(
-      prevEditorState,
-      nextEditorState,
-      dirtyLeaves,
-      dirtyElements,
-      editor.isComposing(),
-    );
-
+    const changeType = getChangeType(prevEditorState, nextEditorState, dirtyLeaves, dirtyElements, editor.isComposing());
     const mergeAction = (() => {
-      const isSameEditor =
-        currentHistoryEntry === null || currentHistoryEntry.editor === editor;
+      const isSameEditor = currentHistoryEntry === null || currentHistoryEntry.editor === editor;
       const shouldPushHistory = tags.has('history-push');
-      const shouldMergeHistory =
-        !shouldPushHistory && isSameEditor && tags.has('history-merge');
-
+      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
-      ) {
+      if (shouldPushHistory === false && changeType !== OTHER && changeType === prevChangeType && changeTime < prevChangeTime + delay && isSameEditor) {
         return HISTORY_MERGE;
       }
 
@@ -298,80 +147,61 @@ function createMergeActionGetter(
       // due to some node transform reverting the change.
       if (dirtyLeaves.size === 1) {
         const dirtyLeafKey = Array.from(dirtyLeaves)[0];
-        if (
-          isTextNodeUnchanged(dirtyLeafKey, prevEditorState, nextEditorState)
-        ) {
+        if (isTextNodeUnchanged(dirtyLeafKey, prevEditorState, nextEditorState)) {
           return HISTORY_MERGE;
         }
       }
-
       return HISTORY_PUSH;
     })();
-
     prevChangeTime = changeTime;
     prevChangeType = changeType;
-
     return mergeAction;
   };
 }
-
-function redo(editor: LexicalEditor, historyState: HistoryState): void {
+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(CAN_UNDO_COMMAND, true);
     }
-
     const historyStateEntry = redoStack.pop();
-
     if (redoStack.length === 0) {
       editor.dispatchCommand(CAN_REDO_COMMAND, false);
     }
-
     historyState.current = historyStateEntry || null;
-
     if (historyStateEntry) {
       historyStateEntry.editor.setEditorState(historyStateEntry.editorState, {
-        tag: 'historic',
+        tag: 'historic'
       });
     }
   }
 }
-
-function undo(editor: LexicalEditor, historyState: HistoryState): void {
+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(CAN_REDO_COMMAND, true);
     }
-
     if (undoStack.length === 0) {
       editor.dispatchCommand(CAN_UNDO_COMMAND, false);
     }
-
     historyState.current = historyStateEntry || null;
-
     if (historyStateEntry) {
       historyStateEntry.editor.setEditorState(historyStateEntry.editorState, {
-        tag: 'historic',
+        tag: 'historic'
       });
     }
   }
 }
-
-function clearHistory(historyState: HistoryState) {
+function clearHistory(historyState) {
   historyState.undoStack = [];
   historyState.redoStack = [];
   historyState.current = null;
@@ -386,53 +216,31 @@ function clearHistory(historyState: HistoryState) {
  * instead of merging the current changes with the current stack.
  * @returns The listeners cleanup callback function.
  */
-export function registerHistory(
-  editor: LexicalEditor,
-  historyState: HistoryState,
-  delay: number,
-): () => void {
+function registerHistory(editor, historyState, delay) {
   const getMergeAction = createMergeActionGetter(editor, delay);
-
   const applyChange = ({
     editorState,
     prevEditorState,
     dirtyLeaves,
     dirtyElements,
-    tags,
-  }: {
-    editorState: EditorState;
-    prevEditorState: EditorState;
-    dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>;
-    dirtyLeaves: Set<NodeKey>;
-    tags: Set<string>;
-  }): void => {
+    tags
+  }) => {
     const current = historyState.current;
     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,
-    );
-
+    const mergeAction = getMergeAction(prevEditorState, editorState, current, dirtyLeaves, dirtyElements, tags);
     if (mergeAction === HISTORY_PUSH) {
       if (redoStack.length !== 0) {
         historyState.redoStack = [];
         editor.dispatchCommand(CAN_REDO_COMMAND, false);
       }
-
       if (current !== null) {
         undoStack.push({
-          ...current,
+          ...current
         });
         editor.dispatchCommand(CAN_UNDO_COMMAND, true);
       }
@@ -443,50 +251,25 @@ export function registerHistory(
     // Else we merge
     historyState.current = {
       editor,
-      editorState,
+      editorState
     };
   };
-
-  const unregisterCommandListener = mergeRegister(
-    editor.registerCommand(
-      UNDO_COMMAND,
-      () => {
-        undo(editor, historyState);
-        return true;
-      },
-      COMMAND_PRIORITY_EDITOR,
-    ),
-    editor.registerCommand(
-      REDO_COMMAND,
-      () => {
-        redo(editor, historyState);
-        return true;
-      },
-      COMMAND_PRIORITY_EDITOR,
-    ),
-    editor.registerCommand(
-      CLEAR_EDITOR_COMMAND,
-      () => {
-        clearHistory(historyState);
-        return false;
-      },
-      COMMAND_PRIORITY_EDITOR,
-    ),
-    editor.registerCommand(
-      CLEAR_HISTORY_COMMAND,
-      () => {
-        clearHistory(historyState);
-        editor.dispatchCommand(CAN_REDO_COMMAND, false);
-        editor.dispatchCommand(CAN_UNDO_COMMAND, false);
-        return true;
-      },
-      COMMAND_PRIORITY_EDITOR,
-    ),
-    editor.registerUpdateListener(applyChange),
-  );
-
+  const unregisterCommandListener = mergeRegister(editor.registerCommand(UNDO_COMMAND, () => {
+    undo(editor, historyState);
+    return true;
+  }, COMMAND_PRIORITY_EDITOR), editor.registerCommand(REDO_COMMAND, () => {
+    redo(editor, historyState);
+    return true;
+  }, COMMAND_PRIORITY_EDITOR), editor.registerCommand(CLEAR_EDITOR_COMMAND, () => {
+    clearHistory(historyState);
+    return false;
+  }, COMMAND_PRIORITY_EDITOR), editor.registerCommand(CLEAR_HISTORY_COMMAND, () => {
+    clearHistory(historyState);
+    editor.dispatchCommand(CAN_REDO_COMMAND, false);
+    editor.dispatchCommand(CAN_UNDO_COMMAND, false);
+    return true;
+  }, COMMAND_PRIORITY_EDITOR), editor.registerUpdateListener(applyChange));
   const unregisterUpdateListener = editor.registerUpdateListener(applyChange);
-
   return () => {
     unregisterCommandListener();
     unregisterUpdateListener();
@@ -497,10 +280,12 @@ export function registerHistory(
  * Creates an empty history state.
  * @returns - The empty history state, as an object.
  */
-export function createEmptyHistoryState(): HistoryState {
+function createEmptyHistoryState() {
   return {
     current: null,
     redoStack: [],
-    undoStack: [],
+    undoStack: []
   };
 }
+
+export { createEmptyHistoryState, registerHistory };

package/LexicalHistory.dev.js

@@ -0,0 +1,294 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var utils = require('@lexical/utils');
+var lexical = require('lexical');
+
+/** @module @lexical/history */
+const HISTORY_MERGE = 0;
+const HISTORY_PUSH = 1;
+const DISCARD_HISTORY_CANDIDATE = 2;
+const OTHER = 0;
+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.
+  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
+    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.
+      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'
+      });
+    }
+  }
+}
+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'
+      });
+    }
+  }
+}
+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.
+ * @param editor - The lexical editor.
+ * @param historyState - The history state, containing the current state and the undo/redo stack.
+ * @param delay - The time (in milliseconds) the editor should delay generating a new history stack,
+ * 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,
+    dirtyLeaves,
+    dirtyElements,
+    tags
+  }) => {
+    const current = historyState.current;
+    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
+        });
+        editor.dispatchCommand(lexical.CAN_UNDO_COMMAND, true);
+      }
+    } else if (mergeAction === DISCARD_HISTORY_CANDIDATE) {
+      return;
+    }
+
+    // Else we merge
+    historyState.current = {
+      editor,
+      editorState
+    };
+  };
+  const unregisterCommandListener = utils.mergeRegister(editor.registerCommand(lexical.UNDO_COMMAND, () => {
+    undo(editor, historyState);
+    return true;
+  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.REDO_COMMAND, () => {
+    redo(editor, historyState);
+    return true;
+  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.CLEAR_EDITOR_COMMAND, () => {
+    clearHistory(historyState);
+    return false;
+  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.CLEAR_HISTORY_COMMAND, () => {
+    clearHistory(historyState);
+    editor.dispatchCommand(lexical.CAN_REDO_COMMAND, false);
+    editor.dispatchCommand(lexical.CAN_UNDO_COMMAND, false);
+    return true;
+  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerUpdateListener(applyChange));
+  const unregisterUpdateListener = editor.registerUpdateListener(applyChange);
+  return () => {
+    unregisterCommandListener();
+    unregisterUpdateListener();
+  };
+}
+
+/**
+ * Creates an empty history state.
+ * @returns - The empty history state, as an object.
+ */
+function createEmptyHistoryState() {
+  return {
+    current: null,
+    redoStack: [],
+    undoStack: []
+  };
+}
+
+exports.createEmptyHistoryState = createEmptyHistoryState;
+exports.registerHistory = registerHistory;

package/LexicalHistory.esm.js

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import * as modDev from './LexicalHistory.dev.esm.js';
+import * as modProd from './LexicalHistory.prod.esm.js';
+const mod = process.env.NODE_ENV === 'development' ? modDev : modProd;
+export const createEmptyHistoryState = mod.createEmptyHistoryState;
+export const registerHistory = mod.registerHistory;

package/LexicalHistory.js

@@ -3,9 +3,7 @@
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
- *
  */
-
-'use strict';
-
-module.exports = require('./dist/LexicalHistory.js');
+'use strict'
+const LexicalHistory = process.env.NODE_ENV === 'development' ? require('./LexicalHistory.dev.js') : require('./LexicalHistory.prod.js');
+module.exports = LexicalHistory;

package/LexicalHistory.prod.esm.js

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import{mergeRegister as t}from"@lexical/utils";import{UNDO_COMMAND as e,COMMAND_PRIORITY_EDITOR as n,REDO_COMMAND as r,CLEAR_EDITOR_COMMAND as o,CLEAR_HISTORY_COMMAND as i,CAN_REDO_COMMAND as s,CAN_UNDO_COMMAND as c,$isRangeSelection as a,$isTextNode as u,$isRootNode as d}from"lexical";const l=0,_=1,f=2,p=0,h=1,m=2,g=3,y=4;function S(t,e,n,r,o){if(null===t||0===n.size&&0===r.size&&!o)return p;const i=e._selection,s=t._selection;if(o)return h;if(!(a(i)&&a(s)&&s.isCollapsed()&&i.isCollapsed()))return p;const c=function(t,e,n){const r=t._nodeMap,o=[];for(const t of e){const e=r.get(t);void 0!==e&&o.push(e)}for(const[t,e]of n){if(!e)continue;const n=r.get(t);void 0===n||d(n)||o.push(n)}return o}(e,n,r);if(0===c.length)return p;if(c.length>1){const n=e._nodeMap,r=n.get(i.anchor.key),o=n.get(s.anchor.key);return r&&o&&!t._nodeMap.has(r.__key)&&u(r)&&1===r.__text.length&&1===i.anchor.offset?m:p}const l=c[0],_=t._nodeMap.get(l.__key);if(!u(_)||!u(l)||_.__mode!==l.__mode)return p;const f=_.__text,S=l.__text;if(f===S)return p;const k=i.anchor,C=s.anchor;if(k.key!==C.key||"text"!==k.type)return p;const x=k.offset,M=C.offset,z=S.length-f.length;return 1===z&&M===x-1?m:-1===z&&M===x+1?g:-1===z&&M===x?y:p}function k(t,e){let n=Date.now(),r=p;return(o,i,s,c,d,h)=>{const m=Date.now();if(h.has("historic"))return r=p,n=m,f;const g=S(o,i,c,d,t.isComposing()),y=(()=>{const y=null===s||s.editor===t,S=h.has("history-push");if(!S&&y&&h.has("history-merge"))return l;if(null===o)return _;const k=i._selection;if(!(c.size>0||d.size>0))return null!==k?l:f;if(!1===S&&g!==p&&g===r&&m<n+e&&y)return l;if(1===c.size){if(function(t,e,n){const r=e._nodeMap.get(t),o=n._nodeMap.get(t),i=e._selection,s=n._selection;let c=!1;return a(i)&&a(s)&&(c="element"===i.anchor.type&&"element"===i.focus.type&&"text"===s.anchor.type&&"text"===s.focus.type),!(c||!u(r)||!u(o))&&r.__type===o.__type&&r.__text===o.__text&&r.__mode===o.__mode&&r.__detail===o.__detail&&r.__style===o.__style&&r.__format===o.__format&&r.__parent===o.__parent}(Array.from(c)[0],o,i))return l}return _})();return n=m,r=g,y}}function C(t){t.undoStack=[],t.redoStack=[],t.current=null}function x(a,u,d){const l=k(a,d),p=({editorState:t,prevEditorState:e,dirtyLeaves:n,dirtyElements:r,tags:o})=>{const i=u.current,d=u.redoStack,p=u.undoStack,h=null===i?null:i.editorState;if(null!==i&&t===h)return;const m=l(e,t,i,n,r,o);if(m===_)0!==d.length&&(u.redoStack=[],a.dispatchCommand(s,!1)),null!==i&&(p.push({...i}),a.dispatchCommand(c,!0));else if(m===f)return;u.current={editor:a,editorState:t}},h=t(a.registerCommand(e,(()=>(function(t,e){const n=e.redoStack,r=e.undoStack;if(0!==r.length){const o=e.current,i=r.pop();null!==o&&(n.push(o),t.dispatchCommand(s,!0)),0===r.length&&t.dispatchCommand(c,!1),e.current=i||null,i&&i.editor.setEditorState(i.editorState,{tag:"historic"})}}(a,u),!0)),n),a.registerCommand(r,(()=>(function(t,e){const n=e.redoStack,r=e.undoStack;if(0!==n.length){const o=e.current;null!==o&&(r.push(o),t.dispatchCommand(c,!0));const i=n.pop();0===n.length&&t.dispatchCommand(s,!1),e.current=i||null,i&&i.editor.setEditorState(i.editorState,{tag:"historic"})}}(a,u),!0)),n),a.registerCommand(o,(()=>(C(u),!1)),n),a.registerCommand(i,(()=>(C(u),a.dispatchCommand(s,!1),a.dispatchCommand(c,!1),!0)),n),a.registerUpdateListener(p)),m=a.registerUpdateListener(p);return()=>{h(),m()}}function M(){return{current:null,redoStack:[],undoStack:[]}}export{M as createEmptyHistoryState,x as registerHistory};

package/LexicalHistory.prod.js

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';var c=require("@lexical/utils"),x=require("lexical");
+function y(b,a,l,h,n){if(null===b||0===l.size&&0===h.size&&!n)return 0;var f=a._selection,d=b._selection;if(n)return 1;if(!(x.$isRangeSelection(f)&&x.$isRangeSelection(d)&&d.isCollapsed()&&f.isCollapsed()))return 0;n=a._nodeMap;let e=[];for(let m of l)l=n.get(m),void 0!==l&&e.push(l);for(let [m,p]of h)p&&(h=n.get(m),void 0===h||x.$isRootNode(h)||e.push(h));if(0===e.length)return 0;if(1<e.length)return h=a._nodeMap,a=h.get(f.anchor.key),d=h.get(d.anchor.key),a&&d&&!b._nodeMap.has(a.__key)&&x.$isTextNode(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 l=Date.now(),h=0;return(n,f,d,e,m,p)=>{let r=Date.now();if(p.has("historic"))return h=0,l=r,2;let q=y(n,f,e,m,b.isComposing()),v=(()=>{var k=null===d||d.editor===b,g=p.has("history-push");if(!g&&k&&p.has("history-merge"))return 0;if(null===n)return 1;var t=f._selection;if(!(0<e.size||0<m.size))return null!==t?0:2;if(!1===g&&0!==q&&q===h&&r<l+a&&k)return 0;if(1===e.size){{g=Array.from(e)[0];k=n._nodeMap.get(g);g=f._nodeMap.get(g);t=n._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);k=!w&&x.$isTextNode(k)&&x.$isTextNode(g)?k.__type===g.__type&&k.__text===g.__text&&k.__mode===g.__mode&&k.__detail===g.__detail&&k.__style===g.__style&&k.__format===g.__format&&k.__parent===g.__parent:!1}if(k)return 0}return 1})();l=r;h=q;return v}}exports.createEmptyHistoryState=function(){return{current:null,redoStack:[],undoStack:[]}};
+exports.registerHistory=function(b,a,l){let h=z(b,l);l=({editorState:d,prevEditorState:e,dirtyLeaves:m,dirtyElements:p,tags:r})=>{const q=a.current,v=a.redoStack,k=a.undoStack,g=null===q?null:q.editorState;if(null===q||d!==g){e=h(e,d,q,m,p,r);if(1===e)0!==v.length&&(a.redoStack=[],b.dispatchCommand(x.CAN_REDO_COMMAND,!1)),null!==q&&(k.push({...q}),b.dispatchCommand(x.CAN_UNDO_COMMAND,!0));else if(2===e)return;a.current={editor:b,editorState:d}}};let n=c.mergeRegister(b.registerCommand(x.UNDO_COMMAND,
+()=>{let d=a.redoStack,e=a.undoStack;if(0!==e.length){let m=a.current,p=e.pop();null!==m&&(d.push(m),b.dispatchCommand(x.CAN_REDO_COMMAND,!0));0===e.length&&b.dispatchCommand(x.CAN_UNDO_COMMAND,!1);a.current=p||null;p&&p.editor.setEditorState(p.editorState,{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 m=a.current;null!==m&&(e.push(m),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(l)),
+f=b.registerUpdateListener(l);return()=>{n();f()}}

package/index.d.ts

@@ -0,0 +1,33 @@
+/** @module @lexical/history */
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { EditorState, LexicalEditor } from 'lexical';
+export type HistoryStateEntry = {
+    editor: LexicalEditor;
+    editorState: EditorState;
+};
+export type HistoryState = {
+    current: null | HistoryStateEntry;
+    redoStack: Array<HistoryStateEntry>;
+    undoStack: Array<HistoryStateEntry>;
+};
+/**
+ * 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.
+ * @param editor - The lexical editor.
+ * @param historyState - The history state, containing the current state and the undo/redo stack.
+ * @param delay - The time (in milliseconds) the editor should delay generating a new history stack,
+ * instead of merging the current changes with the current stack.
+ * @returns The listeners cleanup callback function.
+ */
+export declare function registerHistory(editor: LexicalEditor, historyState: HistoryState, delay: number): () => void;
+/**
+ * Creates an empty history state.
+ * @returns - The empty history state, as an object.
+ */
+export declare function createEmptyHistoryState(): HistoryState;

package/package.json

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

package/src/__tests__/unit/LexicalHistory.test.tsx

@@ -1,323 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-
-import {createEmptyHistoryState, registerHistory} from '@lexical/history';
-import {useLexicalComposerContext} from '@lexical/react/src/LexicalComposerContext';
-import {ContentEditable} from '@lexical/react/src/LexicalContentEditable';
-import LexicalErrorBoundary from '@lexical/react/src/LexicalErrorBoundary';
-import {HistoryPlugin} from '@lexical/react/src/LexicalHistoryPlugin';
-import {RichTextPlugin} from '@lexical/react/src/LexicalRichTextPlugin';
-import {$createQuoteNode} from '@lexical/rich-text/src';
-import {$setBlocksType} from '@lexical/selection/src';
-import {
-  $createNodeSelection,
-  $createRangeSelection,
-  $isNodeSelection,
-  CAN_REDO_COMMAND,
-  CAN_UNDO_COMMAND,
-  CLEAR_HISTORY_COMMAND,
-  COMMAND_PRIORITY_CRITICAL,
-  LexicalEditor,
-  REDO_COMMAND,
-  SerializedElementNode,
-  SerializedTextNode,
-  UNDO_COMMAND,
-} from 'lexical/src';
-import {createTestEditor, TestComposer} from 'lexical/src/__tests__/utils';
-import {$getRoot, $setSelection} from 'lexical/src/LexicalUtils';
-import {$createParagraphNode} from 'lexical/src/nodes/LexicalParagraphNode';
-import {$createTextNode} from 'lexical/src/nodes/LexicalTextNode';
-import React from 'react';
-import {createRoot} from 'react-dom/client';
-import * as ReactTestUtils from 'react-dom/test-utils';
-
-describe('LexicalHistory tests', () => {
-  let container: HTMLDivElement | null = null;
-  let reactRoot;
-
-  beforeEach(() => {
-    container = document.createElement('div');
-    reactRoot = createRoot(container);
-    document.body.appendChild(container);
-  });
-
-  afterEach(() => {
-    if (container !== null) {
-      document.body.removeChild(container);
-    }
-    container = null;
-
-    jest.restoreAllMocks();
-  });
-
-  // Shared instance across tests
-  let editor: LexicalEditor;
-
-  function Test(): JSX.Element {
-    function TestPlugin() {
-      // Plugin used just to get our hands on the Editor object
-      [editor] = useLexicalComposerContext();
-      return null;
-    }
-
-    return (
-      <TestComposer>
-        <RichTextPlugin
-          contentEditable={<ContentEditable />}
-          placeholder={
-            <div className="editor-placeholder">Enter some text...</div>
-          }
-          ErrorBoundary={LexicalErrorBoundary}
-        />
-        <TestPlugin />
-        <HistoryPlugin />
-      </TestComposer>
-    );
-  }
-
-  test('LexicalHistory after clearing', async () => {
-    let canRedo = true;
-    let canUndo = true;
-
-    ReactTestUtils.act(() => {
-      reactRoot.render(<Test key="smth" />);
-    });
-
-    editor.registerCommand<boolean>(
-      CAN_REDO_COMMAND,
-      (payload) => {
-        canRedo = payload;
-        return false;
-      },
-      COMMAND_PRIORITY_CRITICAL,
-    );
-
-    editor.registerCommand<boolean>(
-      CAN_UNDO_COMMAND,
-      (payload) => {
-        canUndo = payload;
-        return false;
-      },
-      COMMAND_PRIORITY_CRITICAL,
-    );
-
-    await Promise.resolve().then();
-
-    await ReactTestUtils.act(async () => {
-      editor.dispatchCommand(CLEAR_HISTORY_COMMAND, undefined);
-    });
-
-    expect(canRedo).toBe(false);
-    expect(canUndo).toBe(false);
-  });
-
-  test('LexicalHistory.Redo after Quote Node', async () => {
-    ReactTestUtils.act(() => {
-      reactRoot.render(<Test key="smth" />);
-    });
-
-    // Wait for update to complete
-    await Promise.resolve().then();
-
-    await ReactTestUtils.act(async () => {
-      await editor.update(() => {
-        const root = $getRoot();
-        const paragraph1 = createParagraphNode('AAA');
-        const paragraph2 = createParagraphNode('BBB');
-
-        // The editor has one child that is an empty
-        // paragraph Node.
-        root.getChildAtIndex(0)?.replace(paragraph1);
-        root.append(paragraph2);
-      });
-    });
-
-    const initialJSONState = editor.getEditorState().toJSON();
-
-    await ReactTestUtils.act(async () => {
-      await editor.update(() => {
-        const root = $getRoot();
-        const selection = $createRangeSelection();
-
-        const firstTextNode = root.getAllTextNodes()[0];
-        selection.anchor.set(firstTextNode.getKey(), 0, 'text');
-        selection.focus.set(firstTextNode.getKey(), 3, 'text');
-
-        $setSelection(selection);
-        $setBlocksType(selection, () => $createQuoteNode());
-      });
-    });
-
-    const afterQuoteInsertionJSONState = editor.getEditorState().toJSON();
-    expect(afterQuoteInsertionJSONState.root.children.length).toBe(2);
-    expect(afterQuoteInsertionJSONState.root.children[0].type).toBe('quote');
-
-    expect(
-      (afterQuoteInsertionJSONState.root.children as SerializedElementNode[])[0]
-        .children.length,
-    ).toBe(1);
-    expect(
-      (afterQuoteInsertionJSONState.root.children as SerializedElementNode[])[0]
-        .children[0].type,
-    ).toBe('text');
-    expect(
-      (
-        (
-          afterQuoteInsertionJSONState.root.children as SerializedElementNode[]
-        )[0].children[0] as SerializedTextNode
-      ).text,
-    ).toBe('AAA');
-
-    await ReactTestUtils.act(async () => {
-      await editor.update(() => {
-        editor.dispatchCommand(UNDO_COMMAND, undefined);
-      });
-    });
-
-    expect(JSON.stringify(initialJSONState)).toBe(
-      JSON.stringify(editor.getEditorState().toJSON()),
-    );
-  });
-
-  test('LexicalHistory in sequence: change, undo, redo, undo, change', async () => {
-    let canRedo = false;
-    let canUndo = false;
-
-    ReactTestUtils.act(() => {
-      reactRoot.render(<Test key="smth" />);
-    });
-
-    editor.registerCommand<boolean>(
-      CAN_REDO_COMMAND,
-      (payload) => {
-        canRedo = payload;
-        return false;
-      },
-      COMMAND_PRIORITY_CRITICAL,
-    );
-
-    editor.registerCommand<boolean>(
-      CAN_UNDO_COMMAND,
-      (payload) => {
-        canUndo = payload;
-        return false;
-      },
-      COMMAND_PRIORITY_CRITICAL,
-    );
-
-    // focus (needs the focus to initialize)
-    await ReactTestUtils.act(async () => {
-      editor.focus();
-    });
-
-    expect(canRedo).toBe(false);
-    expect(canUndo).toBe(false);
-
-    // change
-    await ReactTestUtils.act(async () => {
-      await editor.update(() => {
-        const root = $getRoot();
-        const paragraph = createParagraphNode('foo');
-        root.append(paragraph);
-      });
-    });
-    expect(canRedo).toBe(false);
-    expect(canUndo).toBe(true);
-
-    // undo
-    await ReactTestUtils.act(async () => {
-      await editor.update(() => {
-        editor.dispatchCommand(UNDO_COMMAND, undefined);
-      });
-    });
-    expect(canRedo).toBe(true);
-    expect(canUndo).toBe(false);
-
-    // redo
-    await ReactTestUtils.act(async () => {
-      await editor.update(() => {
-        editor.dispatchCommand(REDO_COMMAND, undefined);
-      });
-    });
-    expect(canRedo).toBe(false);
-    expect(canUndo).toBe(true);
-
-    // undo
-    await ReactTestUtils.act(async () => {
-      await editor.update(() => {
-        editor.dispatchCommand(UNDO_COMMAND, undefined);
-      });
-    });
-    expect(canRedo).toBe(true);
-    expect(canUndo).toBe(false);
-
-    // change
-    await ReactTestUtils.act(async () => {
-      await editor.update(() => {
-        const root = $getRoot();
-        const paragraph = createParagraphNode('foo');
-        root.append(paragraph);
-      });
-    });
-
-    expect(canRedo).toBe(false);
-    expect(canUndo).toBe(true);
-  });
-
-  test('undoStack selection points to the same editor', async () => {
-    const editor_ = createTestEditor({namespace: 'parent'});
-    const sharedHistory = createEmptyHistoryState();
-    registerHistory(editor_, sharedHistory, 1000);
-    await editor_.update(() => {
-      const root = $getRoot();
-      const paragraph = $createParagraphNode();
-      root.append(paragraph);
-    });
-    await editor_.update(() => {
-      const root = $getRoot();
-      const paragraph = $createParagraphNode();
-      root.append(paragraph);
-      const nodeSelection = $createNodeSelection();
-      nodeSelection.add(paragraph.getKey());
-      $setSelection(nodeSelection);
-    });
-    const nestedEditor = createTestEditor({namespace: 'nested'});
-    await nestedEditor.update(
-      () => {
-        const root = $getRoot();
-        const paragraph = $createParagraphNode();
-        root.append(paragraph);
-        paragraph.selectEnd();
-      },
-      {
-        tag: 'history-merge',
-      },
-    );
-    nestedEditor._parentEditor = editor_;
-    registerHistory(nestedEditor, sharedHistory, 1000);
-
-    await nestedEditor.update(() => {
-      const root = $getRoot();
-      const paragraph = $createParagraphNode();
-      root.append(paragraph);
-      paragraph.selectEnd();
-    });
-
-    expect(sharedHistory.undoStack.length).toBe(2);
-    await editor_.dispatchCommand(UNDO_COMMAND, undefined);
-    expect($isNodeSelection(editor_.getEditorState()._selection)).toBe(true);
-  });
-});
-
-const createParagraphNode = (text: string) => {
-  const paragraph = $createParagraphNode();
-  const textNode = $createTextNode(text);
-
-  paragraph.append(textNode);
-  return paragraph;
-};