@lexical/history 0.44.1-nightly.20260519.0 → 0.45.1-dev.0

package/{LexicalHistory.dev.js → dist/LexicalHistory.dev.js}

@@ -259,10 +259,17 @@ function clearHistory(historyState, onChange) {
  * NOT invoked when a candidate update is discarded without changing the
  * stacks. Useful for keeping derived values (e.g. signals) in sync with the
  * current `HistoryState`.
+ * @param maxDepth - The maximum number of entries the undo stack may hold.
+ * When the cap is exceeded a new history event has been pushed the oldest
+ * entries are dropped from the front of the stack until the stack length is
+ * `maxDepth`. Pass `null` (the default) to keep the stack unbounded — the
+ * historical behavior. May be a plain number or a `ReadonlySignal<number | null>`
+ * for reactive reconfiguration.
  * @returns The listeners cleanup callback function.
  */
-function registerHistory(editor, historyState, delay, dateNow = Date.now, onHistoryStateChange) {
+function registerHistory(editor, historyState, delay, dateNow = Date.now, onHistoryStateChange, maxDepth = null) {
   const getMergeAction = createMergeActionGetter(editor, delay, dateNow);
+  const readMaxDepth = () => typeof maxDepth === 'number' || maxDepth === null ? maxDepth : maxDepth.peek();
   const notifyChange = () => {
     if (onHistoryStateChange) {
       onHistoryStateChange(historyState);
@@ -292,6 +299,14 @@ function registerHistory(editor, historyState, delay, dateNow = Date.now, onHist
         undoStack.push({
           ...current
         });
+        const cap = readMaxDepth();
+        if (cap !== null && undoStack.length > cap) {
+          // FIFO-evict the oldest entries so the stack stays at `cap`.
+          // Editing the array in place keeps the same `historyState.undoStack`
+          // reference that callers (e.g. SharedHistoryExtension) may hold on
+          // to.
+          undoStack.splice(0, undoStack.length - cap);
+        }
         editor.dispatchCommand(lexical.CAN_UNDO_COMMAND, true);
       }
     } else if (mergeAction === DISCARD_HISTORY_CANDIDATE) {
@@ -359,6 +374,7 @@ const HistoryExtension = lexical.defineExtension({
     delay,
     createInitialHistoryState,
     disabled,
+    maxDepth,
     now
   }, state) => {
     // The init phase already created writable Signal<boolean> instances for
@@ -371,6 +387,7 @@ const HistoryExtension = lexical.defineExtension({
         delay,
         disabled,
         historyState: createInitialHistoryState(editor),
+        maxDepth,
         now
       }),
       ...state.getInitResult()
@@ -380,6 +397,7 @@ const HistoryExtension = lexical.defineExtension({
     createInitialHistoryState: createEmptyHistoryState,
     delay: 300,
     disabled: typeof window === 'undefined',
+    maxDepth: null,
     now: Date.now
   }),
   init: () => ({
@@ -406,7 +424,7 @@ const HistoryExtension = lexical.defineExtension({
         syncFromHistoryState(null);
         return undefined;
       }
-      return registerHistory(editor, stores.historyState.value, stores.delay, () => stores.now.peek()(), syncFromHistoryState);
+      return registerHistory(editor, stores.historyState.value, stores.delay, () => stores.now.peek()(), syncFromHistoryState, stores.maxDepth);
     });
   }
 });

package/{LexicalHistory.dev.mjs → dist/LexicalHistory.dev.mjs}

@@ -257,10 +257,17 @@ function clearHistory(historyState, onChange) {
  * NOT invoked when a candidate update is discarded without changing the
  * stacks. Useful for keeping derived values (e.g. signals) in sync with the
  * current `HistoryState`.
+ * @param maxDepth - The maximum number of entries the undo stack may hold.
+ * When the cap is exceeded a new history event has been pushed the oldest
+ * entries are dropped from the front of the stack until the stack length is
+ * `maxDepth`. Pass `null` (the default) to keep the stack unbounded — the
+ * historical behavior. May be a plain number or a `ReadonlySignal<number | null>`
+ * for reactive reconfiguration.
  * @returns The listeners cleanup callback function.
  */
-function registerHistory(editor, historyState, delay, dateNow = Date.now, onHistoryStateChange) {
+function registerHistory(editor, historyState, delay, dateNow = Date.now, onHistoryStateChange, maxDepth = null) {
   const getMergeAction = createMergeActionGetter(editor, delay, dateNow);
+  const readMaxDepth = () => typeof maxDepth === 'number' || maxDepth === null ? maxDepth : maxDepth.peek();
   const notifyChange = () => {
     if (onHistoryStateChange) {
       onHistoryStateChange(historyState);
@@ -290,6 +297,14 @@ function registerHistory(editor, historyState, delay, dateNow = Date.now, onHist
         undoStack.push({
           ...current
         });
+        const cap = readMaxDepth();
+        if (cap !== null && undoStack.length > cap) {
+          // FIFO-evict the oldest entries so the stack stays at `cap`.
+          // Editing the array in place keeps the same `historyState.undoStack`
+          // reference that callers (e.g. SharedHistoryExtension) may hold on
+          // to.
+          undoStack.splice(0, undoStack.length - cap);
+        }
         editor.dispatchCommand(CAN_UNDO_COMMAND, true);
       }
     } else if (mergeAction === DISCARD_HISTORY_CANDIDATE) {
@@ -357,6 +372,7 @@ const HistoryExtension = defineExtension({
     delay,
     createInitialHistoryState,
     disabled,
+    maxDepth,
     now
   }, state) => {
     // The init phase already created writable Signal<boolean> instances for
@@ -369,6 +385,7 @@ const HistoryExtension = defineExtension({
         delay,
         disabled,
         historyState: createInitialHistoryState(editor),
+        maxDepth,
         now
       }),
       ...state.getInitResult()
@@ -378,6 +395,7 @@ const HistoryExtension = defineExtension({
     createInitialHistoryState: createEmptyHistoryState,
     delay: 300,
     disabled: typeof window === 'undefined',
+    maxDepth: null,
     now: Date.now
   }),
   init: () => ({
@@ -404,7 +422,7 @@ const HistoryExtension = defineExtension({
         syncFromHistoryState(null);
         return undefined;
       }
-      return registerHistory(editor, stores.historyState.value, stores.delay, () => stores.now.peek()(), syncFromHistoryState);
+      return registerHistory(editor, stores.historyState.value, stores.delay, () => stores.now.peek()(), syncFromHistoryState, stores.maxDepth);
     });
   }
 });

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

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

package/{index.d.ts → dist/index.d.ts}

@@ -29,9 +29,15 @@ export type HistoryState = {
  * NOT invoked when a candidate update is discarded without changing the
  * stacks. Useful for keeping derived values (e.g. signals) in sync with the
  * current `HistoryState`.
+ * @param maxDepth - The maximum number of entries the undo stack may hold.
+ * When the cap is exceeded a new history event has been pushed the oldest
+ * entries are dropped from the front of the stack until the stack length is
+ * `maxDepth`. Pass `null` (the default) to keep the stack unbounded — the
+ * historical behavior. May be a plain number or a `ReadonlySignal<number | null>`
+ * for reactive reconfiguration.
  * @returns The listeners cleanup callback function.
  */
-export declare function registerHistory(editor: LexicalEditor, historyState: HistoryState, delay: number | ReadonlySignal<number>, dateNow?: () => number, onHistoryStateChange?: (state: HistoryState) => void): () => void;
+export declare function registerHistory(editor: LexicalEditor, historyState: HistoryState, delay: number | ReadonlySignal<number>, dateNow?: () => number, onHistoryStateChange?: (state: HistoryState) => void, maxDepth?: number | null | ReadonlySignal<number | null>): () => void;
 /**
  * Creates an empty history state.
  * @returns - The empty history state, as an object.
@@ -55,6 +61,18 @@ export interface HistoryConfig {
      * The now() function, defaults to Date.now.
      */
     now: () => number;
+    /**
+     * The maximum number of entries the undo stack may hold. When the cap is
+     * exceeded the oldest entries are dropped (FIFO) so the stack stays at this
+     * length. Defaults to `null`, which keeps the stack unbounded — the
+     * historical behavior. Setting a finite cap is recommended for editors that
+     * may receive a very large number of distinct history events (long writing
+     * sessions, automated input, etc.) since each entry retains a full
+     * `EditorState` snapshot.
+     *
+     * For reference, ProseMirror's `history()` plugin defaults to `depth: 100`.
+     */
+    maxDepth: number | null;
 }
 /** Internal writable signals created during the init phase. */
 interface HistoryExtensionInit {
@@ -87,6 +105,12 @@ export interface HistoryExtensionOutput {
     disabled: Signal<boolean>;
     /** The active {@link HistoryState} instance. */
     historyState: Signal<HistoryState>;
+    /**
+     * Maximum number of entries the undo stack may hold. `null` disables the
+     * cap. Changes apply to the next history event — the current undo stack is
+     * not retroactively trimmed when the value is lowered.
+     */
+    maxDepth: Signal<number | null>;
     /** The clock function forwarded to {@link registerHistory}. */
     now: Signal<() => number>;
 }

package/package.json

@@ -8,36 +8,50 @@
     "history"
   ],
   "license": "MIT",
-  "version": "0.44.1-nightly.20260519.0",
-  "main": "LexicalHistory.js",
-  "types": "index.d.ts",
+  "version": "0.45.1-dev.0",
+  "main": "./dist/LexicalHistory.js",
+  "types": "./dist/index.d.ts",
   "dependencies": {
-    "@lexical/extension": "0.44.1-nightly.20260519.0",
-    "@lexical/utils": "0.44.1-nightly.20260519.0",
-    "lexical": "0.44.1-nightly.20260519.0"
+    "@lexical/extension": "0.45.1-dev.0",
+    "@lexical/utils": "0.45.1-dev.0",
+    "lexical": "0.45.1-dev.0"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/facebook/lexical.git",
     "directory": "packages/lexical-history"
   },
-  "module": "LexicalHistory.mjs",
+  "module": "./dist/LexicalHistory.mjs",
   "sideEffects": false,
   "exports": {
     ".": {
+      "source": "./src/index.ts",
       "import": {
-        "types": "./index.d.ts",
-        "development": "./LexicalHistory.dev.mjs",
-        "production": "./LexicalHistory.prod.mjs",
-        "node": "./LexicalHistory.node.mjs",
-        "default": "./LexicalHistory.mjs"
+        "types": "./dist/index.d.ts",
+        "development": "./dist/LexicalHistory.dev.mjs",
+        "production": "./dist/LexicalHistory.prod.mjs",
+        "node": "./dist/LexicalHistory.node.mjs",
+        "default": "./dist/LexicalHistory.mjs"
       },
       "require": {
-        "types": "./index.d.ts",
-        "development": "./LexicalHistory.dev.js",
-        "production": "./LexicalHistory.prod.js",
-        "default": "./LexicalHistory.js"
+        "types": "./dist/index.d.ts",
+        "development": "./dist/LexicalHistory.dev.js",
+        "production": "./dist/LexicalHistory.prod.js",
+        "default": "./dist/LexicalHistory.js"
       }
     }
-  }
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/__tests__",
+    "!src/__bench__",
+    "!src/__mocks__",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "!src/**/*.bench.ts",
+    "!src/**/*.bench.tsx",
+    "README.md",
+    "LICENSE"
+  ]
 }

package/src/index.ts

@@ -0,0 +1,807 @@
+/**
+ * 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, LexicalNode, NodeKey} from 'lexical';
+
+import {
+  batch,
+  effect,
+  getPeerDependencyFromEditor,
+  namedSignals,
+  ReadonlySignal,
+  Signal,
+  signal,
+} from '@lexical/extension';
+import {mergeRegister} from '@lexical/utils';
+import {
+  $isRangeSelection,
+  $isRootNode,
+  $isTextNode,
+  CAN_REDO_COMMAND,
+  CAN_UNDO_COMMAND,
+  CLEAR_EDITOR_COMMAND,
+  CLEAR_HISTORY_COMMAND,
+  COMMAND_PRIORITY_EDITOR,
+  COMPOSITION_END_TAG,
+  COMPOSITION_START_TAG,
+  configExtension,
+  defineExtension,
+  HISTORIC_TAG,
+  HISTORY_MERGE_TAG,
+  HISTORY_PUSH_TAG,
+  REDO_COMMAND,
+  safeCast,
+  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;
+
+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 && !$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)
+  ) {
+    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: 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;
+  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: LexicalEditor,
+  delayOrStore: number | ReadonlySignal<number>,
+  dateNow: () => number,
+): (
+  prevEditorState: null | EditorState,
+  nextEditorState: EditorState,
+  currentHistoryEntry: null | HistoryStateEntry,
+  dirtyLeaves: Set<NodeKey>,
+  dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>,
+  tags: Set<string>,
+) => MergeAction {
+  let prevChangeTime = dateNow();
+  let prevChangeType = OTHER;
+  let compositionStartTime = prevChangeTime;
+  let compositionStartChangeType = OTHER;
+  let compositionStartState: EditorState | null = null;
+
+  return (
+    prevEditorState,
+    nextEditorState,
+    currentHistoryEntry,
+    dirtyLeaves,
+    dirtyElements,
+    tags,
+  ) => {
+    const changeTime = dateNow();
+
+    if (tags.has(COMPOSITION_START_TAG)) {
+      compositionStartTime = prevChangeTime;
+      compositionStartChangeType = prevChangeType;
+      compositionStartState = prevEditorState;
+    }
+
+    // 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 isCompositionEnd = tags.has(COMPOSITION_END_TAG);
+    if (isCompositionEnd && compositionStartState) {
+      prevChangeTime = compositionStartTime;
+      prevChangeType = compositionStartChangeType;
+      prevEditorState = compositionStartState;
+    }
+
+    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 (changeType === COMPOSING_CHARACTER) {
+        return DISCARD_HISTORY_CANDIDATE;
+      }
+
+      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: LexicalEditor,
+  historyState: HistoryState,
+  onChange?: (state: HistoryState) => void,
+): 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(CAN_UNDO_COMMAND, true);
+    }
+
+    const historyStateEntry = redoStack.pop();
+
+    if (redoStack.length === 0) {
+      editor.dispatchCommand(CAN_REDO_COMMAND, false);
+    }
+
+    historyState.current = historyStateEntry || null;
+
+    if (onChange) {
+      onChange(historyState);
+    }
+
+    if (historyStateEntry) {
+      historyStateEntry.editor.setEditorState(historyStateEntry.editorState, {
+        tag: HISTORIC_TAG,
+      });
+    }
+  }
+}
+
+function undo(
+  editor: LexicalEditor,
+  historyState: HistoryState,
+  onChange?: (state: HistoryState) => void,
+): 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(CAN_REDO_COMMAND, true);
+    }
+
+    if (undoStack.length === 0) {
+      editor.dispatchCommand(CAN_UNDO_COMMAND, false);
+    }
+
+    historyState.current = historyStateEntry || null;
+
+    if (onChange) {
+      onChange(historyState);
+    }
+
+    if (historyStateEntry) {
+      historyStateEntry.editor.setEditorState(historyStateEntry.editorState, {
+        tag: HISTORIC_TAG,
+      });
+    }
+  }
+}
+
+function clearHistory(
+  historyState: HistoryState,
+  onChange?: (state: HistoryState) => void,
+): void {
+  historyState.undoStack = [];
+  historyState.redoStack = [];
+  historyState.current = null;
+  if (onChange) {
+    onChange(historyState);
+  }
+}
+
+/**
+ * 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.
+ * @param dateNow - The clock function used for delay-based merging.
+ * @param onHistoryStateChange - Optional callback invoked once on registration
+ * and again any time `historyState` is mutated (push, pop, clear, etc.). It is
+ * NOT invoked when a candidate update is discarded without changing the
+ * stacks. Useful for keeping derived values (e.g. signals) in sync with the
+ * current `HistoryState`.
+ * @param maxDepth - The maximum number of entries the undo stack may hold.
+ * When the cap is exceeded a new history event has been pushed the oldest
+ * entries are dropped from the front of the stack until the stack length is
+ * `maxDepth`. Pass `null` (the default) to keep the stack unbounded — the
+ * historical behavior. May be a plain number or a `ReadonlySignal<number | null>`
+ * for reactive reconfiguration.
+ * @returns The listeners cleanup callback function.
+ */
+export function registerHistory(
+  editor: LexicalEditor,
+  historyState: HistoryState,
+  delay: number | ReadonlySignal<number>,
+  dateNow: () => number = Date.now,
+  onHistoryStateChange?: (state: HistoryState) => void,
+  maxDepth: number | null | ReadonlySignal<number | null> = null,
+): () => void {
+  const getMergeAction = createMergeActionGetter(editor, delay, dateNow);
+  const readMaxDepth = (): number | null =>
+    typeof maxDepth === 'number' || maxDepth === null
+      ? maxDepth
+      : maxDepth.peek();
+
+  const notifyChange = () => {
+    if (onHistoryStateChange) {
+      onHistoryStateChange(historyState);
+    }
+  };
+
+  const applyChange = ({
+    editorState,
+    prevEditorState,
+    dirtyLeaves,
+    dirtyElements,
+    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,
+    );
+
+    if (mergeAction === HISTORY_PUSH) {
+      if (redoStack.length !== 0) {
+        historyState.redoStack = [];
+        editor.dispatchCommand(CAN_REDO_COMMAND, false);
+      }
+
+      if (current !== null) {
+        undoStack.push({
+          ...current,
+        });
+        const cap = readMaxDepth();
+        if (cap !== null && undoStack.length > cap) {
+          // FIFO-evict the oldest entries so the stack stays at `cap`.
+          // Editing the array in place keeps the same `historyState.undoStack`
+          // reference that callers (e.g. SharedHistoryExtension) may hold on
+          // to.
+          undoStack.splice(0, undoStack.length - cap);
+        }
+        editor.dispatchCommand(CAN_UNDO_COMMAND, true);
+      }
+    } else if (mergeAction === DISCARD_HISTORY_CANDIDATE) {
+      return;
+    }
+
+    // Else we merge
+    historyState.current = {
+      editor,
+      editorState,
+    };
+    notifyChange();
+  };
+
+  // Allow consumers (e.g. HistoryExtension) to read pre-populated stacks
+  // immediately, without waiting for the first edit.
+  notifyChange();
+
+  return mergeRegister(
+    editor.registerCommand(
+      UNDO_COMMAND,
+      () => {
+        undo(editor, historyState, onHistoryStateChange);
+        return true;
+      },
+      COMMAND_PRIORITY_EDITOR,
+    ),
+    editor.registerCommand(
+      REDO_COMMAND,
+      () => {
+        redo(editor, historyState, onHistoryStateChange);
+        return true;
+      },
+      COMMAND_PRIORITY_EDITOR,
+    ),
+    editor.registerCommand(
+      CLEAR_EDITOR_COMMAND,
+      () => {
+        clearHistory(historyState, onHistoryStateChange);
+        return false;
+      },
+      COMMAND_PRIORITY_EDITOR,
+    ),
+    editor.registerCommand(
+      CLEAR_HISTORY_COMMAND,
+      () => {
+        clearHistory(historyState, onHistoryStateChange);
+        editor.dispatchCommand(CAN_REDO_COMMAND, false);
+        editor.dispatchCommand(CAN_UNDO_COMMAND, false);
+        return true;
+      },
+      COMMAND_PRIORITY_EDITOR,
+    ),
+    editor.registerUpdateListener(applyChange),
+  );
+}
+
+/**
+ * Creates an empty history state.
+ * @returns - The empty history state, as an object.
+ */
+export function createEmptyHistoryState(): HistoryState {
+  return {
+    current: null,
+    redoStack: [],
+    undoStack: [],
+  };
+}
+
+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;
+  /**
+   * The now() function, defaults to Date.now.
+   */
+  now: () => number;
+  /**
+   * The maximum number of entries the undo stack may hold. When the cap is
+   * exceeded the oldest entries are dropped (FIFO) so the stack stays at this
+   * length. Defaults to `null`, which keeps the stack unbounded — the
+   * historical behavior. Setting a finite cap is recommended for editors that
+   * may receive a very large number of distinct history events (long writing
+   * sessions, automated input, etc.) since each entry retains a full
+   * `EditorState` snapshot.
+   *
+   * For reference, ProseMirror's `history()` plugin defaults to `depth: 100`.
+   */
+  maxDepth: number | null;
+}
+
+/** Internal writable signals created during the init phase. */
+interface HistoryExtensionInit {
+  canRedo: Signal<boolean>;
+  canUndo: Signal<boolean>;
+}
+
+/**
+ * The output signals exposed by {@link HistoryExtension}.
+ *
+ * Config-derived signals (`delay`, `disabled`, `historyState`, `now`) are
+ * writable so that peer extensions such as {@link SharedHistoryExtension} can
+ * redirect them at runtime.  The `canUndo` / `canRedo` signals are
+ * **readonly** for consumers — they are derived from the current
+ * {@link HistoryState} and kept in sync automatically.
+ */
+export interface HistoryExtensionOutput {
+  /**
+   * `true` when there is at least one entry in the redo stack, i.e. the
+   * editor can perform a redo.
+   */
+  canRedo: ReadonlySignal<boolean>;
+  /**
+   * `true` when there is at least one entry in the undo stack, i.e. the
+   * editor can perform an undo.
+   */
+  canUndo: ReadonlySignal<boolean>;
+  /** The merge-delay in milliseconds forwarded to {@link registerHistory}. */
+  delay: Signal<number>;
+  /** When `true` the history listener is not registered. */
+  disabled: Signal<boolean>;
+  /** The active {@link HistoryState} instance. */
+  historyState: Signal<HistoryState>;
+  /**
+   * Maximum number of entries the undo stack may hold. `null` disables the
+   * cap. Changes apply to the next history event — the current undo stack is
+   * not retroactively trimmed when the value is lowered.
+   */
+  maxDepth: Signal<number | null>;
+  /** The clock function forwarded to {@link registerHistory}. */
+  now: Signal<() => number>;
+}
+
+/**
+ * Registers necessary listeners to manage undo/redo history stack and related
+ * editor commands, via the \@lexical/history module.
+ */
+export const HistoryExtension = defineExtension({
+  build: (
+    editor,
+    {delay, createInitialHistoryState, disabled, maxDepth, now},
+    state,
+  ): HistoryExtensionOutput => {
+    // The init phase already created writable Signal<boolean> instances for
+    // canUndo/canRedo. Signal<T> extends ReadonlySignal<T>, so exposing them
+    // through the HistoryExtensionOutput type (which declares them as
+    // ReadonlySignal<boolean>) is sufficient to prevent consumers from
+    // mutating them — no computed() wrapper required.
+    return {
+      ...namedSignals({
+        delay,
+        disabled,
+        historyState: createInitialHistoryState(editor),
+        maxDepth,
+        now,
+      }),
+      ...state.getInitResult(),
+    };
+  },
+  config: safeCast<HistoryConfig>({
+    createInitialHistoryState: createEmptyHistoryState,
+    delay: 300,
+    disabled: typeof window === 'undefined',
+    maxDepth: null,
+    now: Date.now,
+  }),
+  init: (): HistoryExtensionInit => ({
+    canRedo: signal(false),
+    canUndo: signal(false),
+  }),
+  name: '@lexical/history/History',
+  register: (editor, config, state) => {
+    const {canUndo, canRedo} = state.getInitResult();
+    const stores = state.getOutput();
+    // Single update path: passing `null` resets both signals (used for the
+    // disabled state); passing a HistoryState derives them from its stacks
+    // (used by registerHistory on init and after every mutation). The batch
+    // ensures subscribers to both signals are only notified once per change.
+    const syncFromHistoryState = (historyState: HistoryState | null) =>
+      batch(() => {
+        canUndo.value =
+          historyState != null && historyState.undoStack.length > 0;
+        canRedo.value =
+          historyState != null && historyState.redoStack.length > 0;
+      });
+    return effect(() => {
+      if (stores.disabled.value) {
+        syncFromHistoryState(null);
+        return undefined;
+      }
+      return registerHistory(
+        editor,
+        stores.historyState.value,
+        stores.delay,
+        () => stores.now.peek()(),
+        syncFromHistoryState,
+        stores.maxDepth,
+      );
+    });
+  },
+});
+
+function getHistoryPeer(editor: LexicalEditor | null | undefined) {
+  return editor
+    ? getPeerDependencyFromEditor<typeof HistoryExtension>(
+        editor,
+        HistoryExtension.name,
+      )
+    : null;
+}
+
+export interface SharedHistoryConfig {
+  /**
+   * Whether shared history is disabled or not
+   */
+  disabled: boolean;
+  /**
+   * The parentEditor to use, by default it is derived from
+   * `config.parentEditor` which can be provided by
+   * NestedEditorExtension
+   */
+  parentEditor: LexicalEditor | 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.
+ */
+export const SharedHistoryExtension = defineExtension({
+  build: (editor, {disabled, parentEditor}) =>
+    namedSignals({
+      disabled,
+      parentEditor: parentEditor || editor._parentEditor,
+    }),
+  config: safeCast<SharedHistoryConfig>({
+    disabled: false,
+    parentEditor: null,
+  }),
+  dependencies: [
+    configExtension(HistoryExtension, {
+      disabled: true,
+    }),
+  ],
+  name: '@lexical/history/SharedHistory',
+  register(editor, _config, state) {
+    return effect(() => {
+      const {disabled, parentEditor} = state.getOutput();
+      if (!disabled.value) {
+        const {output} = state.getDependency(HistoryExtension);
+        const parentPeer = getHistoryPeer(parentEditor.value);
+        if (!parentPeer) {
+          return;
+        }
+        const parentOutput = parentPeer.output;
+        batch(() => {
+          output.delay.value = parentOutput.delay.value;
+          output.historyState.value = parentOutput.historyState.value;
+          output.now.value = parentOutput.now.value;
+          // Note that toggling the parent history will force this to be changed
+          output.disabled.value = parentOutput.disabled.value;
+        });
+      }
+    });
+  },
+});

package/LexicalHistory.prod.js

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

package/LexicalHistory.prod.mjs

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