@bayonai/rich-text-editor 0.1.2 → 1.0.0

package/dist/react/editor/blockActions.js

@@ -0,0 +1,495 @@
+import { isNestableRichTextBlock, } from "../../core/blockTypes.js";
+import { findBlockPath, getBlockAtPath, getBlocksAtPath, insertBlockAtPath, pathContains, removeBlockAtPath, updateBlockAtPath, withBlockChildren, withNestableBlockChildren, } from "../../core/blockTree.js";
+import { richTextBlocksToPlainText, sanitizeRichTextBlocks } from "../../core/richText.js";
+export function isBlockActionTarget(_block) {
+    return true;
+}
+export function reorderBlock(blocks, draggedBlockId, targetBlockId, placement = "before") {
+    if (draggedBlockId === targetBlockId) {
+        return sanitizeRichTextBlocks(blocks);
+    }
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const draggedPath = findBlockPath(sanitizedBlocks, draggedBlockId);
+    const targetPath = findBlockPath(sanitizedBlocks, targetBlockId);
+    if (!draggedPath || !targetPath || pathContains(draggedPath, targetPath)) {
+        return sanitizedBlocks;
+    }
+    const removed = removeBlockAtPath(sanitizedBlocks, draggedPath);
+    if (!removed) {
+        return sanitizedBlocks;
+    }
+    const remainingTargetPath = findBlockPath(removed.blocks, targetBlockId);
+    if (!remainingTargetPath) {
+        return sanitizedBlocks;
+    }
+    if (placement === "inside") {
+        const target = getBlockAtPath(removed.blocks, remainingTargetPath);
+        if (!isNestableRichTextBlock(target)) {
+            const targetIndex = remainingTargetPath[remainingTargetPath.length - 1];
+            if (targetIndex === undefined) {
+                return sanitizedBlocks;
+            }
+            return insertBlockAtPath(removed.blocks, remainingTargetPath.slice(0, -1), targetIndex + 1, [removed.block]);
+        }
+        return updateBlockAtPath(removed.blocks, remainingTargetPath, (current) => {
+            return isNestableRichTextBlock(current)
+                ? withNestableBlockChildren(current, [
+                    ...(current.children ?? []),
+                    removed.block,
+                ])
+                : current;
+        });
+    }
+    const targetIndex = remainingTargetPath[remainingTargetPath.length - 1];
+    if (targetIndex === undefined) {
+        return sanitizedBlocks;
+    }
+    return insertBlockAtPath(removed.blocks, remainingTargetPath.slice(0, -1), placement === "after" ? targetIndex + 1 : targetIndex, [removed.block]);
+}
+export function deleteBlockById(blocks, blockId) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const path = findBlockPath(sanitizedBlocks, blockId);
+    if (!path) {
+        return sanitizedBlocks;
+    }
+    const removed = removeBlockAtPath(sanitizedBlocks, path);
+    const remainingBlocks = removed?.blocks ?? sanitizedBlocks;
+    return remainingBlocks.length > 0
+        ? remainingBlocks
+        : [{ id: "block-empty", markdown: "", type: "paragraph" }];
+}
+export function indentBlock(blocks, blockId) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const path = findBlockPath(sanitizedBlocks, blockId);
+    if (!path || path.length === 0) {
+        return sanitizedBlocks;
+    }
+    const index = path[path.length - 1];
+    if (index === undefined || index <= 0) {
+        return sanitizedBlocks;
+    }
+    const block = getBlockAtPath(sanitizedBlocks, path);
+    const parentPath = path.slice(0, -1);
+    const previousSiblingPath = [...parentPath, index - 1];
+    const previousSibling = getBlockAtPath(sanitizedBlocks, previousSiblingPath);
+    if (!block ||
+        !isNestableRichTextBlock(block) ||
+        !isNestableRichTextBlock(previousSibling)) {
+        return sanitizedBlocks;
+    }
+    const removed = removeBlockAtPath(sanitizedBlocks, path);
+    if (!removed) {
+        return sanitizedBlocks;
+    }
+    const targetPath = findBlockPath(removed.blocks, previousSibling.id);
+    if (!targetPath) {
+        return sanitizedBlocks;
+    }
+    return updateBlockAtPath(removed.blocks, targetPath, (target) => {
+        if (!isNestableRichTextBlock(target)) {
+            return target;
+        }
+        return {
+            ...target,
+            children: [...(target.children ?? []), removed.block],
+        };
+    });
+}
+export function outdentBlock(blocks, blockId) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const path = findBlockPath(sanitizedBlocks, blockId);
+    if (!path || path.length < 2) {
+        return sanitizedBlocks;
+    }
+    const block = getBlockAtPath(sanitizedBlocks, path);
+    const parentPath = path.slice(0, -1);
+    const blockIndex = path[path.length - 1];
+    const siblingBlocks = getBlocksAtPath(sanitizedBlocks, parentPath);
+    if (!block || blockIndex === undefined || !siblingBlocks) {
+        return sanitizedBlocks;
+    }
+    const followingSiblings = siblingBlocks.slice(blockIndex + 1);
+    const removedFollowingSiblings = followingSiblings.reduce((nextBlocks, sibling) => {
+        const siblingPath = findBlockPath(nextBlocks, sibling.id);
+        const removedSibling = siblingPath
+            ? removeBlockAtPath(nextBlocks, siblingPath)
+            : null;
+        return removedSibling?.blocks ?? nextBlocks;
+    }, sanitizedBlocks);
+    const promotedBlock = withBlockChildren(block, [
+        ...(isNestableRichTextBlock(block) ? (block.children ?? []) : []),
+        ...followingSiblings,
+    ]);
+    const removed = removeBlockAtPath(removedFollowingSiblings, path);
+    if (!removed) {
+        return sanitizedBlocks;
+    }
+    const grandParentPath = parentPath.slice(0, -1);
+    const parentIndex = parentPath[parentPath.length - 1];
+    if (parentIndex === undefined) {
+        return sanitizedBlocks;
+    }
+    return insertBlockAtPath(removed.blocks, grandParentPath, parentIndex + 1, [
+        promotedBlock,
+    ]);
+}
+export function setToggleCollapsed(blocks, blockId, collapsed) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const path = findBlockPath(sanitizedBlocks, blockId);
+    if (!path) {
+        return sanitizedBlocks;
+    }
+    return updateBlockAtPath(sanitizedBlocks, path, (block) => {
+        return block.type === "toggle" ? { ...block, collapsed } : block;
+    });
+}
+export function splitTreeRowBlock(blocks, blockId, split) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const path = findBlockPath(sanitizedBlocks, blockId);
+    if (!path) {
+        return sanitizedBlocks;
+    }
+    const block = getBlockAtPath(sanitizedBlocks, path);
+    if (!isNestableRichTextBlock(block)) {
+        return sanitizedBlocks;
+    }
+    const nextBlock = withBlockChildren(getSplitTreeRowNextBlock(block, split), block.children ?? []);
+    const updatedBlocks = updateBlockAtPath(sanitizedBlocks, path, (current) => {
+        return isNestableRichTextBlock(current)
+            ? withBlockChildren({
+                ...current,
+                markdown: split.beforeMarkdown,
+            }, [])
+            : current;
+    });
+    const blockIndex = path[path.length - 1];
+    if (blockIndex === undefined) {
+        return sanitizedBlocks;
+    }
+    return insertBlockAtPath(updatedBlocks, path.slice(0, -1), blockIndex + 1, [
+        nextBlock,
+    ]);
+}
+export function splitTextBlock(blocks, blockId, split) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const path = findBlockPath(sanitizedBlocks, blockId);
+    if (!path) {
+        return sanitizedBlocks;
+    }
+    const block = getBlockAtPath(sanitizedBlocks, path);
+    if (!block || !isSplittableTextBlock(block)) {
+        return sanitizedBlocks;
+    }
+    const updatedBlocks = updateBlockAtPath(sanitizedBlocks, path, (current) => {
+        return current.id === blockId && "markdown" in current
+            ? { ...current, markdown: split.beforeMarkdown }
+            : current;
+    });
+    const blockIndex = path[path.length - 1];
+    if (blockIndex === undefined) {
+        return sanitizedBlocks;
+    }
+    return insertBlockAtPath(updatedBlocks, path.slice(0, -1), blockIndex + 1, [
+        {
+            id: split.nextBlockId,
+            markdown: split.afterMarkdown,
+            type: getSplitTextBlockNextType(block.type, split.afterMarkdown),
+        },
+    ]);
+}
+function getSplitTextBlockNextType(blockType, afterMarkdown) {
+    return blockType === "heading" && afterMarkdown.trim().length === 0
+        ? "paragraph"
+        : blockType;
+}
+function isSplittableTextBlock(block) {
+    return (block?.type === "paragraph" ||
+        block?.type === "heading" ||
+        block?.type === "quote");
+}
+export function insertBlocksAfterBlock(blocks, blockId, insertedBlocks) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const path = findBlockPath(sanitizedBlocks, blockId);
+    if (!path || insertedBlocks.length === 0) {
+        return sanitizedBlocks;
+    }
+    const blockIndex = path[path.length - 1];
+    if (blockIndex === undefined) {
+        return sanitizedBlocks;
+    }
+    return insertBlockAtPath(sanitizedBlocks, path.slice(0, -1), blockIndex + 1, sanitizeRichTextBlocks(insertedBlocks));
+}
+export function replaceBlockWithBlocks(blocks, blockId, replacementBlocks) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const path = findBlockPath(sanitizedBlocks, blockId);
+    if (!path || replacementBlocks.length === 0) {
+        return sanitizedBlocks;
+    }
+    const blockIndex = path[path.length - 1];
+    if (blockIndex === undefined) {
+        return sanitizedBlocks;
+    }
+    const removed = removeBlockAtPath(sanitizedBlocks, path);
+    if (!removed) {
+        return sanitizedBlocks;
+    }
+    return insertBlockAtPath(removed.blocks, path.slice(0, -1), blockIndex, sanitizeRichTextBlocks(replacementBlocks));
+}
+export function insertBlocksInsideBlock(blocks, blockId, insertedBlocks) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const path = findBlockPath(sanitizedBlocks, blockId);
+    if (!path || insertedBlocks.length === 0) {
+        return sanitizedBlocks;
+    }
+    return updateBlockAtPath(sanitizedBlocks, path, (block) => {
+        return isNestableRichTextBlock(block)
+            ? withNestableBlockChildren(block, [
+                ...(block.children ?? []),
+                ...sanitizeRichTextBlocks(insertedBlocks),
+            ])
+            : block;
+    });
+}
+export function getBlockActionBlocks(blocks, blockId) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const range = getActionBlockRange(sanitizedBlocks, blockId);
+    if (range) {
+        return sanitizedBlocks.slice(range.start, range.end);
+    }
+    const path = findBlockPath(sanitizedBlocks, blockId);
+    const block = path ? getBlockAtPath(sanitizedBlocks, path) : null;
+    return block ? [block] : [];
+}
+export function convertCheckboxBlockToParagraph(blocks, blockId) {
+    return convertTreeRowBlockToParagraph(blocks, blockId, (block) => block.markdown, { convertNonEmpty: true });
+}
+export function convertTreeRowBlockToParagraph(blocks, blockId, markdown, options = {}) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const path = findBlockPath(sanitizedBlocks, blockId);
+    if (!path) {
+        return sanitizedBlocks;
+    }
+    return updateBlockAtPath(sanitizedBlocks, path, (block) => {
+        if (!isNestableRichTextBlock(block)) {
+            return block;
+        }
+        if (!options.convertNonEmpty && block.markdown.trim().length > 0) {
+            return block;
+        }
+        return {
+            id: block.id,
+            markdown: typeof markdown === "function" ? markdown(block) : markdown,
+            type: "paragraph",
+        };
+    });
+}
+export function blockToClipboardText(block) {
+    return blockToClipboardTextAtDepth(block, 0);
+}
+function blockToClipboardTextAtDepth(block, depth) {
+    const indent = "  ".repeat(depth);
+    if (block.type === "bullet") {
+        const text = richTextBlocksToPlainText([{ ...block, children: [] }]);
+        const line = text ? `${indent}- ${text}` : "";
+        return [
+            line,
+            ...(block.children ?? []).map((child) => blockToClipboardTextAtDepth(child, depth + 1)),
+        ]
+            .filter((text) => text.trim())
+            .join("\n");
+    }
+    if (block.type === "ordered") {
+        const text = richTextBlocksToPlainText([{ ...block, children: [] }]);
+        const line = text ? `${indent}1. ${text}` : "";
+        return [
+            line,
+            ...(block.children ?? []).map((child) => blockToClipboardTextAtDepth(child, depth + 1)),
+        ]
+            .filter((text) => text.trim())
+            .join("\n");
+    }
+    if (block.type === "checkbox") {
+        const text = richTextBlocksToPlainText([{ ...block, children: [] }]);
+        const line = text ? `${indent}[${block.checked ? "x" : " "}] ${text}` : "";
+        return [
+            line,
+            ...(block.children ?? []).map((child) => blockToClipboardTextAtDepth(child, depth + 1)),
+        ]
+            .filter((value) => value.trim())
+            .join("\n");
+    }
+    if (block.type === "toggle") {
+        const text = richTextBlocksToPlainText([{ ...block, children: [] }]);
+        const line = text ? `${indent}> ${text}` : "";
+        return [
+            line,
+            ...block.children.map((child) => blockToClipboardTextAtDepth(child, depth + 1)),
+        ]
+            .filter((value) => value.trim())
+            .join("\n");
+    }
+    if (block.type === "image") {
+        return richTextBlocksToPlainText([{ ...block, uploadProgress: 0 }]);
+    }
+    return richTextBlocksToPlainText([block]);
+}
+export function blockActionToClipboardText(blocks, blockId) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const range = getActionBlockRange(sanitizedBlocks, blockId);
+    if (range) {
+        return sanitizedBlocks
+            .slice(range.start, range.end)
+            .map(blockToClipboardText)
+            .filter((text) => text.trim())
+            .join("\n");
+    }
+    const path = findBlockPath(sanitizedBlocks, blockId);
+    const block = path ? getBlockAtPath(sanitizedBlocks, path) : null;
+    return block ? blockToClipboardText(block) : "";
+}
+export function getBlockDeletionFocusTarget(blocks, blockId) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const path = findBlockPath(sanitizedBlocks, blockId);
+    if (!path) {
+        return undefined;
+    }
+    const index = path[path.length - 1];
+    const parentPath = path.slice(0, -1);
+    const siblings = getBlocksAtPath(sanitizedBlocks, parentPath);
+    if (index === undefined || !siblings) {
+        return undefined;
+    }
+    const previousBlockId = siblings[index - 1]?.id;
+    if (previousBlockId) {
+        return { blockId: previousBlockId, position: "end" };
+    }
+    const nextBlockId = siblings[index + 1]?.id;
+    if (nextBlockId) {
+        return { blockId: nextBlockId, position: "start" };
+    }
+    if (parentPath.length > 0) {
+        const parent = getBlockAtPath(sanitizedBlocks, parentPath);
+        if (parent) {
+            return { blockId: parent.id, position: "end" };
+        }
+    }
+    return {
+        blockId: "block-empty",
+        position: "start",
+    };
+}
+export function getForwardDeleteFocusTarget(blocks, blockId) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const path = findBlockPath(sanitizedBlocks, blockId);
+    if (!path) {
+        return undefined;
+    }
+    for (let depth = path.length - 1; depth >= 0; depth -= 1) {
+        const parentPath = path.slice(0, depth);
+        const index = path[depth];
+        const siblings = getBlocksAtPath(sanitizedBlocks, parentPath);
+        const nextBlock = index === undefined ? undefined : siblings?.[index + 1];
+        if (nextBlock) {
+            return { blockId: nextBlock.id, position: "start" };
+        }
+    }
+    return undefined;
+}
+export function getToggleContentBackspaceDeletionFocusTarget(blocks, blockId) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const path = findBlockPath(sanitizedBlocks, blockId);
+    if (!path) {
+        return undefined;
+    }
+    const index = path[path.length - 1];
+    const parentPath = path.slice(0, -1);
+    const parent = getBlockAtPath(sanitizedBlocks, parentPath);
+    const siblings = getBlocksAtPath(sanitizedBlocks, parentPath);
+    if (index === undefined ||
+        index <= 0 ||
+        parent?.type !== "toggle" ||
+        !siblings) {
+        return undefined;
+    }
+    const previousSibling = siblings[index - 1];
+    return previousSibling
+        ? { blockId: previousSibling.id, position: "end" }
+        : undefined;
+}
+export function isFirstToggleContentBlock(blocks, blockId) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const path = findBlockPath(sanitizedBlocks, blockId);
+    if (!path) {
+        return false;
+    }
+    const index = path[path.length - 1];
+    const parent = getBlockAtPath(sanitizedBlocks, path.slice(0, -1));
+    return index === 0 && parent?.type === "toggle";
+}
+export function isRootBlockAfterToggle(blocks, blockId) {
+    const sanitizedBlocks = sanitizeRichTextBlocks(blocks);
+    const path = findBlockPath(sanitizedBlocks, blockId);
+    if (!path) {
+        return false;
+    }
+    const index = path[path.length - 1];
+    const parentPath = path.slice(0, -1);
+    const siblings = getBlocksAtPath(sanitizedBlocks, parentPath);
+    if (parentPath.length !== 0 ||
+        index === undefined ||
+        index <= 0 ||
+        !siblings) {
+        return false;
+    }
+    return siblings[index - 1]?.type === "toggle";
+}
+function getSingleBlockRange(blocks, blockId) {
+    const index = blocks.findIndex((block) => {
+        return block.id === blockId;
+    });
+    return index === -1 ? null : { end: index + 1, start: index };
+}
+function getActionBlockRange(blocks, blockId) {
+    const index = blocks.findIndex((block) => {
+        return block.id === blockId;
+    });
+    if (index === -1) {
+        return null;
+    }
+    if (blocks[index]?.type !== "checkbox") {
+        return { end: index + 1, start: index };
+    }
+    let start = index;
+    let end = index + 1;
+    while (start > 0 && blocks[start - 1]?.type === "checkbox") {
+        start -= 1;
+    }
+    while (end < blocks.length && blocks[end]?.type === "checkbox") {
+        end += 1;
+    }
+    return { end, start };
+}
+function getSplitTreeRowNextBlock(block, split) {
+    if (block.type === "checkbox") {
+        return {
+            checked: false,
+            id: split.nextBlockId,
+            markdown: split.afterMarkdown,
+            type: "checkbox",
+        };
+    }
+    if (block.type === "toggle") {
+        return {
+            children: [],
+            collapsed: false,
+            id: split.nextBlockId,
+            markdown: split.afterMarkdown,
+            type: "toggle",
+        };
+    }
+    return {
+        id: split.nextBlockId,
+        markdown: split.afterMarkdown,
+        type: block.type,
+    };
+}

package/dist/react/editor/editorHistory.d.ts

@@ -0,0 +1,55 @@
+import type { RichTextBlock, RichTextDocument, RichTextSelectionSnapshot } from "../../core/types";
+export type RichTextHistoryLabel = "block-delete" | "block-indent" | "block-insert" | "block-outdent" | "block-reorder" | "format" | "image" | "link" | "paste" | "redo" | "title" | "toggle-collapse" | "transcription" | "typing" | "undo";
+export type RichTextHistoryEntry = {
+    document: RichTextDocument;
+    label: RichTextHistoryLabel;
+    metadata?: RichTextHistoryMetadata;
+    selection: RichTextSelectionSnapshot | null;
+    timestamp: number;
+};
+export type RichTextHistoryState = {
+    future: RichTextHistoryEntry[];
+    maxDepth: number;
+    past: RichTextHistoryEntry[];
+    present: RichTextHistoryEntry;
+};
+export type RichTextHistorySnapshotEntry = {
+    id: string;
+    label: RichTextHistoryLabel;
+    metadata?: RichTextHistoryMetadata;
+    timestamp: number;
+};
+export type RichTextHistorySnapshot = {
+    canRedo: boolean;
+    canUndo: boolean;
+    currentIndex: number;
+    entries: RichTextHistorySnapshotEntry[];
+};
+export type RichTextHistoryCommit = {
+    document: RichTextDocument;
+    label: RichTextHistoryLabel;
+    metadata?: RichTextHistoryMetadata;
+    selection: RichTextSelectionSnapshot | null;
+    timestamp?: number;
+};
+export type RichTextHistoryMetadata = {
+    blockType?: RichTextBlock["type"];
+};
+export declare function createRichTextHistory({ document, maxDepth, selection, timestamp, }: {
+    document: RichTextDocument;
+    maxDepth?: number;
+    selection?: RichTextSelectionSnapshot | null;
+    timestamp?: number;
+}): RichTextHistoryState;
+export declare function commitRichTextHistory(history: RichTextHistoryState, commit: RichTextHistoryCommit): RichTextHistoryState;
+export declare function canUndoRichTextHistory(history: RichTextHistoryState): boolean;
+export declare function canRedoRichTextHistory(history: RichTextHistoryState): boolean;
+export declare function undoRichTextHistory(history: RichTextHistoryState): {
+    entry: RichTextHistoryEntry;
+    history: RichTextHistoryState;
+};
+export declare function redoRichTextHistory(history: RichTextHistoryState): {
+    entry: RichTextHistoryEntry;
+    history: RichTextHistoryState;
+};
+export declare function createRichTextHistorySnapshot(history: RichTextHistoryState): RichTextHistorySnapshot;

package/dist/react/editor/editorHistory.js

@@ -0,0 +1,111 @@
+import { canonicalSerialize } from "../../session/session.js";
+const DEFAULT_HISTORY_DEPTH = 100;
+const TYPING_COALESCE_MS = 1000;
+export function createRichTextHistory({ document, maxDepth = DEFAULT_HISTORY_DEPTH, selection = null, timestamp = Date.now(), }) {
+    return {
+        future: [],
+        maxDepth,
+        past: [],
+        present: {
+            document,
+            label: "typing",
+            selection,
+            timestamp,
+        },
+    };
+}
+export function commitRichTextHistory(history, commit) {
+    const timestamp = commit.timestamp ?? Date.now();
+    const nextEntry = {
+        document: commit.document,
+        label: commit.label,
+        metadata: commit.metadata,
+        selection: commit.selection,
+        timestamp,
+    };
+    if (areDocumentsEqual(history.present.document, nextEntry.document)) {
+        return history;
+    }
+    if (shouldCoalesceHistoryEntry(history.present, nextEntry)) {
+        return {
+            ...history,
+            future: [],
+            present: nextEntry,
+        };
+    }
+    return {
+        ...history,
+        future: [],
+        past: [...history.past, history.present].slice(-history.maxDepth),
+        present: nextEntry,
+    };
+}
+export function canUndoRichTextHistory(history) {
+    return history.past.length > 0;
+}
+export function canRedoRichTextHistory(history) {
+    return history.future.length > 0;
+}
+export function undoRichTextHistory(history) {
+    const previous = history.past[history.past.length - 1];
+    if (!previous) {
+        return { entry: history.present, history };
+    }
+    return {
+        entry: previous,
+        history: {
+            ...history,
+            future: [history.present, ...history.future],
+            past: history.past.slice(0, -1),
+            present: previous,
+        },
+    };
+}
+export function redoRichTextHistory(history) {
+    const next = history.future[0];
+    if (!next) {
+        return { entry: history.present, history };
+    }
+    return {
+        entry: next,
+        history: {
+            ...history,
+            future: history.future.slice(1),
+            past: [...history.past, history.present].slice(-history.maxDepth),
+            present: next,
+        },
+    };
+}
+export function createRichTextHistorySnapshot(history) {
+    const entries = [...history.past, history.present, ...history.future].map((entry, index) => ({
+        id: `history-${index}-${entry.timestamp}`,
+        label: entry.label,
+        ...(entry.metadata ? { metadata: entry.metadata } : {}),
+        timestamp: entry.timestamp,
+    }));
+    return {
+        canRedo: canRedoRichTextHistory(history),
+        canUndo: canUndoRichTextHistory(history),
+        currentIndex: history.past.length,
+        entries,
+    };
+}
+function shouldCoalesceHistoryEntry(previous, next) {
+    if (previous.label !== next.label) {
+        return false;
+    }
+    if (next.label !== "typing" && next.label !== "title") {
+        return false;
+    }
+    if (next.timestamp - previous.timestamp > TYPING_COALESCE_MS) {
+        return false;
+    }
+    if (next.label === "title") {
+        return true;
+    }
+    return (previous.selection?.blockId !== undefined &&
+        previous.selection.blockId === next.selection?.blockId);
+}
+function areDocumentsEqual(left, right) {
+    return canonicalSerialize(left) === canonicalSerialize(right);
+}

package/dist/react/{editorNavigation.d.ts → editor/editorNavigation.d.ts}

@@ -13,7 +13,9 @@ type SelectionLike = {
     };
 };
 export type EditorKeyboardShortcutCommand = "bold" | "italic" | "link";
+export type EditorHistoryShortcutCommand = "redo" | "undo";
 export declare function isSelectAllShortcut(event: SelectAllShortcutLike): boolean | undefined;
 export declare function getEditorKeyboardShortcut(event: SelectAllShortcutLike): EditorKeyboardShortcutCommand | null;
+export declare function getEditorHistoryShortcut(event: SelectAllShortcutLike): EditorHistoryShortcutCommand | null;
 export declare function getCodeBlockSelectionTarget(root: Element, selection: SelectionLike | null): Element | null;
 export {};

package/dist/react/{editorNavigation.js → editor/editorNavigation.js}

@@ -23,6 +23,22 @@ export function getEditorKeyboardShortcut(event) {
     }
     return null;
 }
+export function getEditorHistoryShortcut(event) {
+    if (!(event.ctrlKey || event.metaKey) || event.altKey) {
+        return null;
+    }
+    const key = event.key.toLowerCase();
+    if (key === "z" && event.shiftKey) {
+        return "redo";
+    }
+    if (key === "z" && !event.shiftKey) {
+        return "undo";
+    }
+    if (key === "y" && !event.shiftKey) {
+        return "redo";
+    }
+    return null;
+}
 export function getCodeBlockSelectionTarget(root, selection) {
     if (!selection || selection.rangeCount === 0) {
         return null;