@ekz/lexical-history 0.40.0

package/EkzLexicalHistory.dev.js

@@ -0,0 +1,363 @@
+/**
+ * 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 lexicalExtension = require('@ekz/lexical-extension');
+var lexicalUtils = require('@ekz/lexical-utils');
+var lexical = require('@ekz/lexical');
+
+/**
+ * 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.
+ *
+ */
+
+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;
+  const isDeletingLine = lexical.$isRangeSelection(prevSelection) && lexical.$isRangeSelection(nextSelection) && prevSelection.anchor.type === 'element' && prevSelection.focus.type === 'element' && nextSelection.anchor.type === 'text' && nextSelection.focus.type === 'text';
+  if (!isDeletingLine && lexical.$isTextNode(prevNode) && lexical.$isTextNode(nextNode) && prevNode.__parent === nextNode.__parent) {
+    // This has the assumption that object key order won't change if the
+    // content did not change, which should normally be safe given
+    // the manner in which nodes and exportJSON are typically implemented.
+    return JSON.stringify(prevEditorState.read(() => prevNode.exportJSON())) === JSON.stringify(nextEditorState.read(() => nextNode.exportJSON()));
+  }
+  return false;
+}
+function createMergeActionGetter(editor, delayOrStore) {
+  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(lexical.HISTORIC_TAG)) {
+      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(lexical.HISTORY_PUSH_TAG);
+      const shouldMergeHistory = !shouldPushHistory && isSameEditor && tags.has(lexical.HISTORY_MERGE_TAG);
+      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;
+      }
+      const delay = typeof delayOrStore === 'number' ? delayOrStore : delayOrStore.peek();
+      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: lexical.HISTORIC_TAG
+      });
+    }
+  }
+}
+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: lexical.HISTORIC_TAG
+      });
+    }
+  }
+}
+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 unregister = lexicalUtils.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));
+  return unregister;
+}
+
+/**
+ * Creates an empty history state.
+ * @returns - The empty history state, as an object.
+ */
+function createEmptyHistoryState() {
+  return {
+    current: null,
+    redoStack: [],
+    undoStack: []
+  };
+}
+/**
+ * Registers necessary listeners to manage undo/redo history stack and related
+ * editor commands, via the \@lexical/history module.
+ */
+
+const HistoryExtension = lexical.defineExtension({
+  build: (editor, {
+    delay,
+    createInitialHistoryState,
+    disabled
+  }) => lexicalExtension.namedSignals({
+    delay,
+    disabled,
+    historyState: createInitialHistoryState(editor)
+  }),
+  config: lexical.safeCast({
+    createInitialHistoryState: createEmptyHistoryState,
+    delay: 300,
+    disabled: typeof window === 'undefined'
+  }),
+  name: '@ekz/lexical-history/History',
+  register: (editor, config, state) => {
+    const stores = state.getOutput();
+    return lexicalExtension.effect(() => stores.disabled.value ? undefined : registerHistory(editor, stores.historyState.value, stores.delay));
+  }
+});
+function getHistoryPeer(editor) {
+  return editor ? lexicalExtension.getPeerDependencyFromEditor(editor, HistoryExtension.name) : null;
+}
+
+/**
+ * Registers necessary listeners to manage undo/redo history stack and related
+ * editor commands, via the \@lexical/history module, only if the parent editor
+ * has a history plugin implementation.
+ */
+const SharedHistoryExtension = lexical.defineExtension({
+  dependencies: [lexical.configExtension(HistoryExtension, {
+    createInitialHistoryState: () => {
+      throw new Error('SharedHistory did not inherit parent history');
+    },
+    disabled: true
+  })],
+  name: '@ekz/lexical-history/SharedHistory',
+  register(editor, _config, state) {
+    const {
+      output
+    } = state.getDependency(HistoryExtension);
+    const parentPeer = getHistoryPeer(editor._parentEditor);
+    if (!parentPeer) {
+      return () => {};
+    }
+    const parentOutput = parentPeer.output;
+    return lexicalExtension.effect(() => lexicalExtension.batch(() => {
+      output.delay.value = parentOutput.delay.value;
+      output.historyState.value = parentOutput.historyState.value;
+      // Note that toggling the parent history will force this to be changed
+      output.disabled.value = parentOutput.disabled.value;
+    }));
+  }
+});
+
+exports.HistoryExtension = HistoryExtension;
+exports.SharedHistoryExtension = SharedHistoryExtension;
+exports.createEmptyHistoryState = createEmptyHistoryState;
+exports.registerHistory = registerHistory;

package/EkzLexicalHistory.dev.mjs

@@ -0,0 +1,358 @@
+/**
+ * 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 { namedSignals, effect, batch, getPeerDependencyFromEditor } from '@ekz/lexical-extension';
+import { mergeRegister } from '@ekz/lexical-utils';
+import { defineExtension, safeCast, configExtension, UNDO_COMMAND, COMMAND_PRIORITY_EDITOR, REDO_COMMAND, CLEAR_EDITOR_COMMAND, CLEAR_HISTORY_COMMAND, CAN_REDO_COMMAND, CAN_UNDO_COMMAND, HISTORIC_TAG, HISTORY_PUSH_TAG, HISTORY_MERGE_TAG, $isRangeSelection, $isTextNode, $isRootNode } from '@ekz/lexical';
+
+/**
+ * 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.
+ *
+ */
+
+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 && !$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 (!$isRangeSelection(nextSelection) || !$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) && $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) {
+    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;
+  const isDeletingLine = $isRangeSelection(prevSelection) && $isRangeSelection(nextSelection) && prevSelection.anchor.type === 'element' && prevSelection.focus.type === 'element' && nextSelection.anchor.type === 'text' && nextSelection.focus.type === 'text';
+  if (!isDeletingLine && $isTextNode(prevNode) && $isTextNode(nextNode) && prevNode.__parent === nextNode.__parent) {
+    // This has the assumption that object key order won't change if the
+    // content did not change, which should normally be safe given
+    // the manner in which nodes and exportJSON are typically implemented.
+    return JSON.stringify(prevEditorState.read(() => prevNode.exportJSON())) === JSON.stringify(nextEditorState.read(() => nextNode.exportJSON()));
+  }
+  return false;
+}
+function createMergeActionGetter(editor, delayOrStore) {
+  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_TAG)) {
+      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_TAG);
+      const shouldMergeHistory = !shouldPushHistory && isSameEditor && tags.has(HISTORY_MERGE_TAG);
+      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;
+      }
+      const delay = typeof delayOrStore === 'number' ? delayOrStore : delayOrStore.peek();
+      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(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
+      });
+    }
+  }
+}
+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
+      });
+    }
+  }
+}
+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(CAN_REDO_COMMAND, false);
+      }
+      if (current !== null) {
+        undoStack.push({
+          ...current
+        });
+        editor.dispatchCommand(CAN_UNDO_COMMAND, true);
+      }
+    } else if (mergeAction === DISCARD_HISTORY_CANDIDATE) {
+      return;
+    }
+
+    // Else we merge
+    historyState.current = {
+      editor,
+      editorState
+    };
+  };
+  const unregister = 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));
+  return unregister;
+}
+
+/**
+ * Creates an empty history state.
+ * @returns - The empty history state, as an object.
+ */
+function createEmptyHistoryState() {
+  return {
+    current: null,
+    redoStack: [],
+    undoStack: []
+  };
+}
+/**
+ * Registers necessary listeners to manage undo/redo history stack and related
+ * editor commands, via the \@lexical/history module.
+ */
+
+const HistoryExtension = defineExtension({
+  build: (editor, {
+    delay,
+    createInitialHistoryState,
+    disabled
+  }) => namedSignals({
+    delay,
+    disabled,
+    historyState: createInitialHistoryState(editor)
+  }),
+  config: safeCast({
+    createInitialHistoryState: createEmptyHistoryState,
+    delay: 300,
+    disabled: typeof window === 'undefined'
+  }),
+  name: '@ekz/lexical-history/History',
+  register: (editor, config, state) => {
+    const stores = state.getOutput();
+    return effect(() => stores.disabled.value ? undefined : registerHistory(editor, stores.historyState.value, stores.delay));
+  }
+});
+function getHistoryPeer(editor) {
+  return editor ? getPeerDependencyFromEditor(editor, HistoryExtension.name) : null;
+}
+
+/**
+ * Registers necessary listeners to manage undo/redo history stack and related
+ * editor commands, via the \@lexical/history module, only if the parent editor
+ * has a history plugin implementation.
+ */
+const SharedHistoryExtension = defineExtension({
+  dependencies: [configExtension(HistoryExtension, {
+    createInitialHistoryState: () => {
+      throw new Error('SharedHistory did not inherit parent history');
+    },
+    disabled: true
+  })],
+  name: '@ekz/lexical-history/SharedHistory',
+  register(editor, _config, state) {
+    const {
+      output
+    } = state.getDependency(HistoryExtension);
+    const parentPeer = getHistoryPeer(editor._parentEditor);
+    if (!parentPeer) {
+      return () => {};
+    }
+    const parentOutput = parentPeer.output;
+    return effect(() => batch(() => {
+      output.delay.value = parentOutput.delay.value;
+      output.historyState.value = parentOutput.historyState.value;
+      // Note that toggling the parent history will force this to be changed
+      output.disabled.value = parentOutput.disabled.value;
+    }));
+  }
+});
+
+export { HistoryExtension, SharedHistoryExtension, createEmptyHistoryState, registerHistory };

package/EkzLexicalHistory.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.
+ *
+ */
+
+'use strict'
+const EkzLexicalHistory = process.env.NODE_ENV !== 'production' ? require('./EkzLexicalHistory.dev.js') : require('./EkzLexicalHistory.prod.js');
+module.exports = EkzLexicalHistory;

package/EkzLexicalHistory.mjs

@@ -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.
+ *
+ */
+
+import * as modDev from './EkzLexicalHistory.dev.mjs';
+import * as modProd from './EkzLexicalHistory.prod.mjs';
+const mod = process.env.NODE_ENV !== 'production' ? modDev : modProd;
+export const HistoryExtension = mod.HistoryExtension;
+export const SharedHistoryExtension = mod.SharedHistoryExtension;
+export const createEmptyHistoryState = mod.createEmptyHistoryState;
+export const registerHistory = mod.registerHistory;

package/EkzLexicalHistory.node.mjs

@@ -0,0 +1,13 @@
+/**
+ * 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.
+ *
+ */
+
+const mod = await (process.env.NODE_ENV !== 'production' ? import('./EkzLexicalHistory.dev.mjs') : import('./EkzLexicalHistory.prod.mjs'));
+export const HistoryExtension = mod.HistoryExtension;
+export const SharedHistoryExtension = mod.SharedHistoryExtension;
+export const createEmptyHistoryState = mod.createEmptyHistoryState;
+export const registerHistory = mod.registerHistory;

package/EkzLexicalHistory.prod.js

@@ -0,0 +1,9 @@
+/**
+ * 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 e=require("@ekz/lexical-extension"),t=require("@ekz/lexical-utils"),n=require("@ekz/lexical");function r(e,t,r,o,i){if(null===e||0===r.size&&0===o.size&&!i)return 0;const s=t._selection,a=e._selection;if(i)return 1;if(!(n.$isRangeSelection(s)&&n.$isRangeSelection(a)&&a.isCollapsed()&&s.isCollapsed()))return 0;const c=function(e,t,r){const o=e._nodeMap,i=[];for(const e of t){const t=o.get(e);void 0!==t&&i.push(t)}for(const[e,t]of r){if(!t)continue;const r=o.get(e);void 0===r||n.$isRootNode(r)||i.push(r)}return i}(t,r,o);if(0===c.length)return 0;if(c.length>1){const r=t._nodeMap,o=r.get(s.anchor.key),i=r.get(a.anchor.key);return o&&i&&!e._nodeMap.has(o.__key)&&n.$isTextNode(o)&&1===o.__text.length&&1===s.anchor.offset?2:0}const d=c[0],u=e._nodeMap.get(d.__key);if(!n.$isTextNode(u)||!n.$isTextNode(d)||u.__mode!==d.__mode)return 0;const l=u.__text,_=d.__text;if(l===_)return 0;const f=s.anchor,p=a.anchor;if(f.key!==p.key||"text"!==f.type)return 0;const h=f.offset,O=p.offset,S=_.length-l.length;return 1===S&&O===h-1?2:-1===S&&O===h+1?3:-1===S&&O===h?4:0}function o(e,t){let o=Date.now(),i=0;return(s,a,c,d,u,l)=>{const _=Date.now();if(l.has(n.HISTORIC_TAG))return i=0,o=_,2;const f=r(s,a,d,u,e.isComposing()),p=(()=>{const r=null===c||c.editor===e,p=l.has(n.HISTORY_PUSH_TAG);if(!p&&r&&l.has(n.HISTORY_MERGE_TAG))return 0;if(null===s)return 1;const h=a._selection;if(!(d.size>0||u.size>0))return null!==h?0:2;const O="number"==typeof t?t:t.peek();if(!1===p&&0!==f&&f===i&&_<o+O&&r)return 0;if(1===d.size){if(function(e,t,r){const o=t._nodeMap.get(e),i=r._nodeMap.get(e),s=t._selection,a=r._selection;return!(n.$isRangeSelection(s)&&n.$isRangeSelection(a)&&"element"===s.anchor.type&&"element"===s.focus.type&&"text"===a.anchor.type&&"text"===a.focus.type||!n.$isTextNode(o)||!n.$isTextNode(i)||o.__parent!==i.__parent)&&JSON.stringify(t.read(()=>o.exportJSON()))===JSON.stringify(r.read(()=>i.exportJSON()))}(Array.from(d)[0],s,a))return 0}return 1})();return o=_,i=f,p}}function i(e){e.undoStack=[],e.redoStack=[],e.current=null}function s(e,r,s){const a=o(e,s),c=t.mergeRegister(e.registerCommand(n.UNDO_COMMAND,()=>(function(e,t){const r=t.redoStack,o=t.undoStack;if(0!==o.length){const i=t.current,s=o.pop();null!==i&&(r.push(i),e.dispatchCommand(n.CAN_REDO_COMMAND,!0)),0===o.length&&e.dispatchCommand(n.CAN_UNDO_COMMAND,!1),t.current=s||null,s&&s.editor.setEditorState(s.editorState,{tag:n.HISTORIC_TAG})}}(e,r),!0),n.COMMAND_PRIORITY_EDITOR),e.registerCommand(n.REDO_COMMAND,()=>(function(e,t){const r=t.redoStack,o=t.undoStack;if(0!==r.length){const i=t.current;null!==i&&(o.push(i),e.dispatchCommand(n.CAN_UNDO_COMMAND,!0));const s=r.pop();0===r.length&&e.dispatchCommand(n.CAN_REDO_COMMAND,!1),t.current=s||null,s&&s.editor.setEditorState(s.editorState,{tag:n.HISTORIC_TAG})}}(e,r),!0),n.COMMAND_PRIORITY_EDITOR),e.registerCommand(n.CLEAR_EDITOR_COMMAND,()=>(i(r),!1),n.COMMAND_PRIORITY_EDITOR),e.registerCommand(n.CLEAR_HISTORY_COMMAND,()=>(i(r),e.dispatchCommand(n.CAN_REDO_COMMAND,!1),e.dispatchCommand(n.CAN_UNDO_COMMAND,!1),!0),n.COMMAND_PRIORITY_EDITOR),e.registerUpdateListener(({editorState:t,prevEditorState:o,dirtyLeaves:i,dirtyElements:s,tags:c})=>{const d=r.current,u=r.redoStack,l=r.undoStack,_=null===d?null:d.editorState;if(null!==d&&t===_)return;const f=a(o,t,d,i,s,c);if(1===f)0!==u.length&&(r.redoStack=[],e.dispatchCommand(n.CAN_REDO_COMMAND,!1)),null!==d&&(l.push({...d}),e.dispatchCommand(n.CAN_UNDO_COMMAND,!0));else if(2===f)return;r.current={editor:e,editorState:t}}));return c}function a(){return{current:null,redoStack:[],undoStack:[]}}const c=n.defineExtension({build:(t,{delay:n,createInitialHistoryState:r,disabled:o})=>e.namedSignals({delay:n,disabled:o,historyState:r(t)}),config:n.safeCast({createInitialHistoryState:a,delay:300,disabled:"undefined"==typeof window}),name:"@ekz/lexical-history/History",register:(t,n,r)=>{const o=r.getOutput();return e.effect(()=>o.disabled.value?void 0:s(t,o.historyState.value,o.delay))}});const d=n.defineExtension({dependencies:[n.configExtension(c,{createInitialHistoryState:()=>{throw new Error("SharedHistory did not inherit parent history")},disabled:!0})],name:"@ekz/lexical-history/SharedHistory",register(t,n,r){const{output:o}=r.getDependency(c),i=function(t){return t?e.getPeerDependencyFromEditor(t,c.name):null}(t._parentEditor);if(!i)return()=>{};const s=i.output;return e.effect(()=>e.batch(()=>{o.delay.value=s.delay.value,o.historyState.value=s.historyState.value,o.disabled.value=s.disabled.value}))}});exports.HistoryExtension=c,exports.SharedHistoryExtension=d,exports.createEmptyHistoryState=a,exports.registerHistory=s;

package/EkzLexicalHistory.prod.mjs

@@ -0,0 +1,9 @@
+/**
+ * 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{namedSignals as t,effect as e,batch as n,getPeerDependencyFromEditor as r}from"@ekz/lexical-extension";import{mergeRegister as o}from"@ekz/lexical-utils";import{defineExtension as i,safeCast as a,configExtension as s,UNDO_COMMAND as c,COMMAND_PRIORITY_EDITOR as d,REDO_COMMAND as u,CLEAR_EDITOR_COMMAND as l,CLEAR_HISTORY_COMMAND as f,CAN_REDO_COMMAND as p,CAN_UNDO_COMMAND as h,HISTORIC_TAG as m,HISTORY_PUSH_TAG as y,HISTORY_MERGE_TAG as g,$isRangeSelection as S,$isTextNode as _,$isRootNode as k}from"@ekz/lexical";function x(t,e,n,r,o){if(null===t||0===n.size&&0===r.size&&!o)return 0;const i=e._selection,a=t._selection;if(o)return 1;if(!(S(i)&&S(a)&&a.isCollapsed()&&i.isCollapsed()))return 0;const s=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||k(n)||o.push(n)}return o}(e,n,r);if(0===s.length)return 0;if(s.length>1){const n=e._nodeMap,r=n.get(i.anchor.key),o=n.get(a.anchor.key);return r&&o&&!t._nodeMap.has(r.__key)&&_(r)&&1===r.__text.length&&1===i.anchor.offset?2:0}const c=s[0],d=t._nodeMap.get(c.__key);if(!_(d)||!_(c)||d.__mode!==c.__mode)return 0;const u=d.__text,l=c.__text;if(u===l)return 0;const f=i.anchor,p=a.anchor;if(f.key!==p.key||"text"!==f.type)return 0;const h=f.offset,m=p.offset,y=l.length-u.length;return 1===y&&m===h-1?2:-1===y&&m===h+1?3:-1===y&&m===h?4:0}function C(t,e){let n=Date.now(),r=0;return(o,i,a,s,c,d)=>{const u=Date.now();if(d.has(m))return r=0,n=u,2;const l=x(o,i,s,c,t.isComposing()),f=(()=>{const f=null===a||a.editor===t,p=d.has(y);if(!p&&f&&d.has(g))return 0;if(null===o)return 1;const h=i._selection;if(!(s.size>0||c.size>0))return null!==h?0:2;const m="number"==typeof e?e:e.peek();if(!1===p&&0!==l&&l===r&&u<n+m&&f)return 0;if(1===s.size){if(function(t,e,n){const r=e._nodeMap.get(t),o=n._nodeMap.get(t),i=e._selection,a=n._selection;return!(S(i)&&S(a)&&"element"===i.anchor.type&&"element"===i.focus.type&&"text"===a.anchor.type&&"text"===a.focus.type||!_(r)||!_(o)||r.__parent!==o.__parent)&&JSON.stringify(e.read(()=>r.exportJSON()))===JSON.stringify(n.read(()=>o.exportJSON()))}(Array.from(s)[0],o,i))return 0}return 1})();return n=u,r=l,f}}function v(t){t.undoStack=[],t.redoStack=[],t.current=null}function z(t,e,n){const r=C(t,n),i=o(t.registerCommand(c,()=>(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(p,!0)),0===r.length&&t.dispatchCommand(h,!1),e.current=i||null,i&&i.editor.setEditorState(i.editorState,{tag:m})}}(t,e),!0),d),t.registerCommand(u,()=>(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(h,!0));const i=n.pop();0===n.length&&t.dispatchCommand(p,!1),e.current=i||null,i&&i.editor.setEditorState(i.editorState,{tag:m})}}(t,e),!0),d),t.registerCommand(l,()=>(v(e),!1),d),t.registerCommand(f,()=>(v(e),t.dispatchCommand(p,!1),t.dispatchCommand(h,!1),!0),d),t.registerUpdateListener(({editorState:n,prevEditorState:o,dirtyLeaves:i,dirtyElements:a,tags:s})=>{const c=e.current,d=e.redoStack,u=e.undoStack,l=null===c?null:c.editorState;if(null!==c&&n===l)return;const f=r(o,n,c,i,a,s);if(1===f)0!==d.length&&(e.redoStack=[],t.dispatchCommand(p,!1)),null!==c&&(u.push({...c}),t.dispatchCommand(h,!0));else if(2===f)return;e.current={editor:t,editorState:n}}));return i}function b(){return{current:null,redoStack:[],undoStack:[]}}const w=i({build:(e,{delay:n,createInitialHistoryState:r,disabled:o})=>t({delay:n,disabled:o,historyState:r(e)}),config:a({createInitialHistoryState:b,delay:300,disabled:"undefined"==typeof window}),name:"@ekz/lexical-history/History",register:(t,n,r)=>{const o=r.getOutput();return e(()=>o.disabled.value?void 0:z(t,o.historyState.value,o.delay))}});const E=i({dependencies:[s(w,{createInitialHistoryState:()=>{throw new Error("SharedHistory did not inherit parent history")},disabled:!0})],name:"@ekz/lexical-history/SharedHistory",register(t,o,i){const{output:a}=i.getDependency(w),s=function(t){return t?r(t,w.name):null}(t._parentEditor);if(!s)return()=>{};const c=s.output;return e(()=>n(()=>{a.delay.value=c.delay.value,a.historyState.value=c.historyState.value,a.disabled.value=c.disabled.value}))}});export{w as HistoryExtension,E as SharedHistoryExtension,b as createEmptyHistoryState,z as registerHistory};

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/LexicalHistory.js.flow

@@ -0,0 +1,39 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+import type {LexicalExtension, ExtensionConfigBase, EditorState, BaseSelection, LexicalEditor} from '@ekz/lexical';
+import type {NamedSignalsOutput} from '@ekz/lexical-extension';
+
+export type HistoryStateEntry = {
+  editor: LexicalEditor,
+  editorState: EditorState,
+  undoSelection?: BaseSelection | null,
+};
+export type HistoryState = {
+  current: null | HistoryStateEntry,
+  redoStack: Array<HistoryStateEntry>,
+  undoStack: Array<HistoryStateEntry>,
+};
+declare export function registerHistory(
+  editor: LexicalEditor,
+  historyState: HistoryState,
+  delay: number,
+): () => void;
+declare export function createEmptyHistoryState(): HistoryState;
+
+export type HistoryConfig = {
+  delay: number;
+  createInitialHistoryState: (editor: LexicalEditor) => HistoryState;
+  disabled: boolean;
+}
+declare export var HistoryExtension: LexicalExtension<HistoryConfig, "@ekz/lexical-history/History", NamedSignalsOutput<{
+    delay: number;
+    disabled: boolean;
+    historyState: HistoryState;
+}>, void>;
+declare export var SharedHistoryExtension: LexicalExtension<ExtensionConfigBase, "@ekz/lexical-history/SharedHistory", void, void>;

package/README.md

@@ -0,0 +1,32 @@
+# `@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
+
+#### `registerHistory`
+
+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.
+
+```js
+function registerHistory(
+  editor: LexicalEditor,
+  externalHistoryState: HistoryState,
+  delay: number,
+): () => void
+```
+
+### Commands
+
+History package handles `UNDO_COMMAND`, `REDO_COMMAND` and `CLEAR_HISTORY_COMMAND` commands. It also triggers `CAN_UNDO_COMMAND` and `CAN_REDO_COMMAND` commands when history state is changed. These commands could be used to work with history state:
+
+```jsx
+import {UNDO_COMMAND, REDO_COMMAND} from '@ekz/lexical';
+
+<Toolbar>
+  <Button onClick={() => editor.dispatchCommand(UNDO_COMMAND, undefined)}>Undo</Button>
+  <Button onClick={() => editor.dispatchCommand(REDO_COMMAND, undefined)}>Redo</Button>
+</Toolbar>;
+```

package/index.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 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 '@ekz/lexical';
+import { ReadonlySignal } from '@ekz/lexical-extension';
+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 | ReadonlySignal<number>): () => void;
+/**
+ * Creates an empty history state.
+ * @returns - The empty history state, as an object.
+ */
+export declare function createEmptyHistoryState(): HistoryState;
+export interface HistoryConfig {
+    /**
+     * The time (in milliseconds) the editor should delay generating a new history stack,
+     * instead of merging the current changes with the current stack. The default is 300ms.
+     */
+    delay: number;
+    /**
+     * The initial history state, the default is {@link createEmptyHistoryState}.
+     */
+    createInitialHistoryState: (editor: LexicalEditor) => HistoryState;
+    /**
+     * Whether history is disabled or not
+     */
+    disabled: boolean;
+}
+/**
+ * Registers necessary listeners to manage undo/redo history stack and related
+ * editor commands, via the \@lexical/history module.
+ */
+export declare const HistoryExtension: import("@ekz/lexical").LexicalExtension<HistoryConfig, "@ekz/lexical-history/History", import("@ekz/lexical-extension").NamedSignalsOutput<{
+    delay: number;
+    disabled: boolean;
+    historyState: HistoryState;
+}>, unknown>;
+/**
+ * Registers necessary listeners to manage undo/redo history stack and related
+ * editor commands, via the \@lexical/history module, only if the parent editor
+ * has a history plugin implementation.
+ */
+export declare const SharedHistoryExtension: import("@ekz/lexical").LexicalExtension<import("@ekz/lexical").ExtensionConfigBase, "@ekz/lexical-history/SharedHistory", unknown, unknown>;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@ekz/lexical-history",
+  "description": "This package contains selection history helpers for Lexical.",
+  "keywords": [
+    "lexical",
+    "editor",
+    "rich-text",
+    "history"
+  ],
+  "license": "MIT",
+  "version": "0.40.0",
+  "main": "LexicalHistory.js",
+  "types": "index.d.ts",
+  "dependencies": {
+    "@ekz/lexical-extension": "0.40.0",
+    "@ekz/lexical-utils": "0.40.0",
+    "@ekz/lexical": "0.40.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/facebook/lexical.git",
+    "directory": "packages/lexical-history"
+  },
+  "module": "LexicalHistory.mjs",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./index.d.ts",
+        "development": "./LexicalHistory.dev.mjs",
+        "production": "./LexicalHistory.prod.mjs",
+        "node": "./LexicalHistory.node.mjs",
+        "default": "./LexicalHistory.mjs"
+      },
+      "require": {
+        "types": "./index.d.ts",
+        "development": "./LexicalHistory.dev.js",
+        "production": "./LexicalHistory.prod.js",
+        "default": "./LexicalHistory.js"
+      }
+    }
+  }
+}