@blocklet/editor-lite 2.6.0

package/lib/vendor/LexicalCharacterLimitPlugin/useCharacterLimit.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 { LexicalEditor } from 'lexical';
+import { OverflowNode } from '@lexical/overflow';
+type OptionalProps = {
+    remainingCharacters?: (characters: number) => void;
+    strlen?: (input: string) => number;
+};
+export declare function useCharacterLimit(editor: LexicalEditor, maxCharacters: number, optional?: OptionalProps): void;
+export declare function $mergePrevious(overflowNode: OverflowNode): void;
+export {};

package/lib/vendor/LexicalCharacterLimitPlugin/useCharacterLimit.js

@@ -0,0 +1,208 @@
+/**
+ * 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 { $createOverflowNode, $isOverflowNode, OverflowNode } from '@lexical/overflow';
+import { $rootTextContent } from '@lexical/text';
+import { $dfs, $unwrapNode, mergeRegister } from '@lexical/utils';
+import { $getSelection, $isElementNode, $isLeafNode, $isRangeSelection, $isTextNode, $setSelection, COMMAND_PRIORITY_LOW, DELETE_CHARACTER_COMMAND, } from 'lexical';
+import { useEffect } from 'react';
+import invariant from '../../shared/invariant';
+export function useCharacterLimit(editor, maxCharacters, optional = Object.freeze({})) {
+    const { strlen = (input) => input.length, 
+    // UTF-16
+    remainingCharacters = () => { }, } = optional;
+    useEffect(() => {
+        if (!editor.hasNodes([OverflowNode])) {
+            invariant(false, 'useCharacterLimit: OverflowNode not registered on editor');
+        }
+    }, [editor]);
+    useEffect(() => {
+        let text = editor.getEditorState().read($rootTextContent);
+        let lastComputedTextLength = 0;
+        return mergeRegister(editor.registerTextContentListener((currentText) => {
+            text = currentText;
+        }), editor.registerUpdateListener((payload) => {
+            if (!payload)
+                return;
+            const { dirtyLeaves, dirtyElements } = payload;
+            const isComposing = editor.isComposing();
+            const hasContentChanges = dirtyLeaves.size > 0 || dirtyElements.size > 0;
+            if (isComposing || !hasContentChanges) {
+                return;
+            }
+            const textLength = strlen(text);
+            const textLengthAboveThreshold = textLength > maxCharacters || (lastComputedTextLength !== null && lastComputedTextLength > maxCharacters);
+            const diff = maxCharacters - textLength;
+            remainingCharacters(diff);
+            if (lastComputedTextLength === null || textLengthAboveThreshold) {
+                const offset = findOffset(text, maxCharacters, strlen);
+                editor.update(() => {
+                    $wrapOverflowedNodes(offset);
+                }, {
+                    tag: 'history-merge',
+                });
+            }
+            lastComputedTextLength = textLength;
+        }), editor.registerCommand(DELETE_CHARACTER_COMMAND, (isBackward) => {
+            const selection = $getSelection();
+            if (!$isRangeSelection(selection)) {
+                return false;
+            }
+            const anchorNode = selection.anchor.getNode();
+            const overflow = anchorNode.getParent();
+            const overflowParent = overflow ? overflow.getParent() : null;
+            const parentNext = overflowParent ? overflowParent.getNextSibling() : null;
+            selection.deleteCharacter(isBackward);
+            if (overflowParent && overflowParent.isEmpty()) {
+                overflowParent.remove();
+            }
+            else if ($isElementNode(parentNext) && parentNext.isEmpty()) {
+                parentNext.remove();
+            }
+            return true;
+        }, COMMAND_PRIORITY_LOW));
+    }, [editor, maxCharacters, remainingCharacters, strlen]);
+}
+function findOffset(text, maxCharacters, strlen) {
+    const { Segmenter } = Intl;
+    let offsetUtf16 = 0;
+    let offset = 0;
+    if (typeof Segmenter === 'function') {
+        const segmenter = new Segmenter();
+        const graphemes = segmenter.segment(text);
+        for (const { segment: grapheme } of graphemes) {
+            const nextOffset = offset + strlen(grapheme);
+            if (nextOffset > maxCharacters) {
+                break;
+            }
+            offset = nextOffset;
+            offsetUtf16 += grapheme.length;
+        }
+    }
+    else {
+        const codepoints = Array.from(text);
+        const codepointsLength = codepoints.length;
+        for (let i = 0; i < codepointsLength; i++) {
+            const codepoint = codepoints[i];
+            const nextOffset = offset + strlen(codepoint);
+            if (nextOffset > maxCharacters) {
+                break;
+            }
+            offset = nextOffset;
+            offsetUtf16 += codepoint.length;
+        }
+    }
+    return offsetUtf16;
+}
+function $wrapOverflowedNodes(offset) {
+    const dfsNodes = $dfs().filter(Boolean);
+    const dfsNodesLength = dfsNodes.length;
+    let accumulatedLength = 0;
+    for (let i = 0; i < dfsNodesLength; i += 1) {
+        const { node } = dfsNodes[i];
+        if ($isOverflowNode(node)) {
+            const previousLength = accumulatedLength;
+            const nextLength = accumulatedLength + node.getTextContentSize();
+            if (nextLength <= offset) {
+                const parent = node.getParent();
+                const previousSibling = node.getPreviousSibling();
+                const nextSibling = node.getNextSibling();
+                $unwrapNode(node);
+                const selection = $getSelection();
+                // Restore selection when the overflow children are removed
+                if ($isRangeSelection(selection) &&
+                    (!selection.anchor.getNode().isAttached() || !selection.focus.getNode().isAttached())) {
+                    if ($isTextNode(previousSibling)) {
+                        previousSibling.select();
+                    }
+                    else if ($isTextNode(nextSibling)) {
+                        nextSibling.select();
+                    }
+                    else if (parent !== null) {
+                        parent.select();
+                    }
+                }
+            }
+            else if (previousLength < offset) {
+                const descendant = node.getFirstDescendant();
+                const descendantLength = descendant !== null ? descendant.getTextContentSize() : 0;
+                const previousPlusDescendantLength = previousLength + descendantLength;
+                // For simple text we can redimension the overflow into a smaller and more accurate
+                // container
+                const firstDescendantIsSimpleText = $isTextNode(descendant) && descendant.isSimpleText();
+                const firstDescendantDoesNotOverflow = previousPlusDescendantLength <= offset;
+                if (firstDescendantIsSimpleText || firstDescendantDoesNotOverflow) {
+                    $unwrapNode(node);
+                }
+            }
+        }
+        else if ($isLeafNode(node)) {
+            const previousAccumulatedLength = accumulatedLength;
+            accumulatedLength += node.getTextContentSize();
+            if (accumulatedLength > offset && !$isOverflowNode(node.getParent())) {
+                const previousSelection = $getSelection();
+                let overflowNode;
+                // For simple text we can improve the limit accuracy by splitting the TextNode
+                // on the split point
+                if (previousAccumulatedLength < offset && $isTextNode(node) && node.isSimpleText()) {
+                    const [, overflowedText] = node.splitText(offset - previousAccumulatedLength);
+                    overflowNode = $wrapNode(overflowedText);
+                }
+                else {
+                    overflowNode = $wrapNode(node);
+                }
+                if (previousSelection !== null) {
+                    $setSelection(previousSelection);
+                }
+                $mergePrevious(overflowNode);
+            }
+        }
+    }
+}
+function $wrapNode(node) {
+    const overflowNode = $createOverflowNode();
+    node.replace(overflowNode);
+    overflowNode.append(node);
+    return overflowNode;
+}
+export function $mergePrevious(overflowNode) {
+    const previousNode = overflowNode.getPreviousSibling();
+    if (!$isOverflowNode(previousNode)) {
+        return;
+    }
+    const firstChild = overflowNode.getFirstChild();
+    const previousNodeChildren = previousNode.getChildren();
+    const previousNodeChildrenLength = previousNodeChildren.length;
+    if (firstChild === null) {
+        overflowNode.append(...previousNodeChildren);
+    }
+    else {
+        for (let i = 0; i < previousNodeChildrenLength; i++) {
+            firstChild.insertBefore(previousNodeChildren[i]);
+        }
+    }
+    const selection = $getSelection();
+    if ($isRangeSelection(selection)) {
+        const { anchor } = selection;
+        const anchorNode = anchor.getNode();
+        const { focus } = selection;
+        const focusNode = anchor.getNode();
+        if (anchorNode.is(previousNode)) {
+            anchor.set(overflowNode.getKey(), anchor.offset, 'element');
+        }
+        else if (anchorNode.is(overflowNode)) {
+            anchor.set(overflowNode.getKey(), previousNodeChildrenLength + anchor.offset, 'element');
+        }
+        if (focusNode.is(previousNode)) {
+            focus.set(overflowNode.getKey(), focus.offset, 'element');
+        }
+        else if (focusNode.is(overflowNode)) {
+            focus.set(overflowNode.getKey(), previousNodeChildrenLength + focus.offset, 'element');
+        }
+    }
+    previousNode.remove();
+}

package/lib/vendor/history/LexicalHistoryPlugin.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 { HistoryState } from './history';
+export { createEmptyHistoryState } from './history';
+export type { HistoryState };
+export declare function HistoryPlugin({ delay, externalHistoryState, }: {
+    delay?: number;
+    externalHistoryState?: HistoryState;
+}): null;

package/lib/vendor/history/LexicalHistoryPlugin.js

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useHistory } from './useHistory';
+export { createEmptyHistoryState } from './history';
+export function HistoryPlugin({ delay, externalHistoryState, }) {
+    const [editor] = useLexicalComposerContext();
+    useHistory(editor, externalHistoryState, delay);
+    return null;
+}

package/lib/vendor/history/history/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 'lexical';
+import { ReadonlySignal } from '@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("lexical").LexicalExtension<HistoryConfig, "@lexical/history/History", import("@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("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@lexical/history/SharedHistory", unknown, unknown>;

package/lib/vendor/history/history/index.js

@@ -0,0 +1,351 @@
+/**
+ * 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 { batch, effect, getPeerDependencyFromEditor, namedSignals } 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, configExtension, defineExtension, HISTORIC_TAG, HISTORY_MERGE_TAG, HISTORY_PUSH_TAG, REDO_COMMAND, safeCast, UNDO_COMMAND, } from 'lexical';
+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) {
+            // eslint-disable-next-line no-continue
+            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;
+    const { undoStack } = historyState;
+    if (redoStack.length !== 0) {
+        const { current } = historyState;
+        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;
+    const { undoStack } = historyState;
+    const undoStackLength = undoStack.length;
+    if (undoStackLength !== 0) {
+        const { current } = historyState;
+        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.
+ */
+export function registerHistory(editor, historyState, delay) {
+    const getMergeAction = createMergeActionGetter(editor, delay);
+    const applyChange = (payload) => {
+        if (!payload)
+            return;
+        const { editorState, prevEditorState, dirtyLeaves, dirtyElements, tags } = payload;
+        const { current } = historyState;
+        const { redoStack } = historyState;
+        const { undoStack } = historyState;
+        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.
+ */
+export 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.
+ */
+export 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: '@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.
+ */
+export const SharedHistoryExtension = defineExtension({
+    dependencies: [
+        configExtension(HistoryExtension, {
+            createInitialHistoryState: () => {
+                throw new Error('SharedHistory did not inherit parent history');
+            },
+            disabled: true,
+        }),
+    ],
+    name: '@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;
+        }));
+    },
+});

package/lib/vendor/history/useHistory.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 { LexicalEditor } from 'lexical';
+import type { HistoryState } from './history';
+export declare function useHistory(editor: LexicalEditor, externalHistoryState?: HistoryState, delay?: number): void;