@lexical/history 0.13.0 → 0.14.0

package/LexicalHistory.js

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

package/README.md

@@ -1,5 +1,7 @@
 # `@lexical/history`
 
+[![See API Documentation](https://lexical.dev/img/see-api-documentation.svg)](https://lexical.dev/docs/api/modules/lexical_history)
+
 This package contains history helpers for Lexical.
 
 ### Methods

package/package.json

@@ -8,17 +8,19 @@
     "history"
   ],
   "license": "MIT",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "main": "LexicalHistory.js",
   "peerDependencies": {
-    "lexical": "0.13.0"
+    "lexical": "0.14.0"
   },
   "dependencies": {
-    "@lexical/utils": "0.13.0"
+    "@lexical/utils": "0.14.0"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/facebook/lexical",
     "directory": "packages/lexical-history"
-  }
+  },
+  "module": "LexicalHistory.esm.js",
+  "sideEffects": false
 }

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

@@ -0,0 +1,323 @@
+/**
+ * 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;
+};

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

@@ -1,56 +1,119 @@
+/** @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.
+ *
  */
-'use strict';
 
-var utils = require('@lexical/utils');
-var lexical = require('lexical');
+import type {EditorState, LexicalEditor, LexicalNode, NodeKey} from 'lexical';
 
-/** @module @lexical/history */
+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;
 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;
-function getDirtyNodes(editorState, dirtyLeaves, dirtyElements) {
+
+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> {
   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)) {
+
+    if (dirtyElement !== undefined && !$isRootNode(dirtyElement)) {
       nodes.push(dirtyElement);
     }
   }
+
   return nodes;
 }
-function getChangeType(prevEditorState, nextEditorState, dirtyLeavesSet, dirtyElementsSet, isComposing) {
-  if (prevEditorState === null || dirtyLeavesSet.size === 0 && dirtyElementsSet.size === 0 && !isComposing) {
+
+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)
+  ) {
     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()) {
+
+  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;
   }
@@ -61,58 +124,122 @@ function getChangeType(prevEditorState, nextEditorState, dirtyLeavesSet, dirtyEl
     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) {
+
+    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 (!lexical.$isTextNode(prevDirtyNode) || !lexical.$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, prevEditorState, nextEditorState) {
+
+function isTextNodeUnchanged(
+  key: NodeKey,
+  prevEditorState: EditorState,
+  nextEditorState: EditorState,
+): boolean {
   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 ($isRangeSelection(prevSelection) && $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;
+
+  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 false;
 }
-function createMergeActionGetter(editor, delay) {
+
+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 {
   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
@@ -122,26 +249,48 @@ function createMergeActionGetter(editor, delay) {
       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;
       }
 
@@ -149,61 +298,80 @@ function createMergeActionGetter(editor, delay) {
       // 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, historyState) {
+
+function redo(editor: LexicalEditor, historyState: HistoryState): void {
   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);
+      editor.dispatchCommand(CAN_UNDO_COMMAND, true);
     }
+
     const historyStateEntry = redoStack.pop();
+
     if (redoStack.length === 0) {
-      editor.dispatchCommand(lexical.CAN_REDO_COMMAND, false);
+      editor.dispatchCommand(CAN_REDO_COMMAND, false);
     }
+
     historyState.current = historyStateEntry || null;
+
     if (historyStateEntry) {
       historyStateEntry.editor.setEditorState(historyStateEntry.editorState, {
-        tag: 'historic'
+        tag: 'historic',
       });
     }
   }
 }
-function undo(editor, historyState) {
+
+function undo(editor: LexicalEditor, historyState: HistoryState): void {
   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);
+      editor.dispatchCommand(CAN_REDO_COMMAND, true);
     }
+
     if (undoStack.length === 0) {
-      editor.dispatchCommand(lexical.CAN_UNDO_COMMAND, false);
+      editor.dispatchCommand(CAN_UNDO_COMMAND, false);
     }
+
     historyState.current = historyStateEntry || null;
+
     if (historyStateEntry) {
       historyStateEntry.editor.setEditorState(historyStateEntry.editorState, {
-        tag: 'historic'
+        tag: 'historic',
       });
     }
   }
 }
-function clearHistory(historyState) {
+
+function clearHistory(historyState: HistoryState) {
   historyState.undoStack = [];
   historyState.redoStack = [];
   historyState.current = null;
@@ -218,33 +386,55 @@ function clearHistory(historyState) {
  * instead of merging the current changes with the current stack.
  * @returns The listeners cleanup callback function.
  */
-function registerHistory(editor, historyState, delay) {
+export function registerHistory(
+  editor: LexicalEditor,
+  historyState: HistoryState,
+  delay: number,
+): () => void {
   const getMergeAction = createMergeActionGetter(editor, delay);
+
   const applyChange = ({
     editorState,
     prevEditorState,
     dirtyLeaves,
     dirtyElements,
-    tags
-  }) => {
+    tags,
+  }: {
+    editorState: EditorState;
+    prevEditorState: EditorState;
+    dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>;
+    dirtyLeaves: Set<NodeKey>;
+    tags: Set<string>;
+  }): void => {
     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(lexical.CAN_REDO_COMMAND, false);
+        editor.dispatchCommand(CAN_REDO_COMMAND, false);
       }
+
       if (current !== null) {
         undoStack.push({
-          ...current
+          ...current,
         });
-        editor.dispatchCommand(lexical.CAN_UNDO_COMMAND, true);
+        editor.dispatchCommand(CAN_UNDO_COMMAND, true);
       }
     } else if (mergeAction === DISCARD_HISTORY_CANDIDATE) {
       return;
@@ -253,25 +443,50 @@ function registerHistory(editor, historyState, delay) {
     // Else we merge
     historyState.current = {
       editor,
-      editorState
+      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 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();
@@ -282,13 +497,10 @@ function registerHistory(editor, historyState, delay) {
  * Creates an empty history state.
  * @returns - The empty history state, as an object.
  */
-function createEmptyHistoryState() {
+export function createEmptyHistoryState(): HistoryState {
   return {
     current: null,
     redoStack: [],
-    undoStack: []
+    undoStack: [],
   };
 }
-
-exports.createEmptyHistoryState = createEmptyHistoryState;
-exports.registerHistory = registerHistory;

package/LICENSE

@@ -1,21 +0,0 @@
-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/LexicalHistory.prod.js

@@ -1,15 +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.
- */
-'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

@@ -1,33 +0,0 @@
-/** @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;