@inshapardaz/likhari-react 0.1.8 → 0.1.9-dev.94

package/dist/EditorRoot.d.ts

@@ -3,7 +3,10 @@ import type { SerializedEditorState } from 'lexical';
 import { type FormatId } from '@inshapardaz/likhari-converters';
 import { type EditorFeatureConfig, type FeatureConfigPresetName } from '@inshapardaz/likhari-core';
 import { type FontOption } from './fonts/index.js';
+import { type DraftRestoreMode } from './components/DraftRestore.js';
 import { type Locale } from './i18n/index.js';
+/** What happens when the user is about to leave with unsaved changes. */
+export type NavigationGuardMode = 'confirm' | 'save-draft' | 'off';
 export interface EditorInitialContent {
     format: Extract<FormatId, 'lexical-json' | 'plain-text'>;
     value: string;
@@ -70,6 +73,63 @@ export interface EditorRootProps {
      * `[...DEFAULT_FONT_OPTIONS, { name: 'Mine', family: '"Mine", serif' }]`.
      */
     fontOptions?: FontOption[];
+    /**
+     * Saves drafts: a debounced autosave of the current content to
+     * `localStorage` (lexical-editor-spec.md §6.2), a resilience net against an
+     * accidental tab close that is independent of `onSave`/the Save button. The
+     * draft is stored under `documentId` when you give one (§6.1); without one, a
+     * unique id is generated for this editor, so editors never overwrite each
+     * other's drafts. The toolbar's Drafts button lists every draft in the browser
+     * to restore or delete. A draft is cleared on a successful explicit save.
+     * Defaults to `true`.
+     */
+    autosave?: boolean;
+    /**
+     * What to do on mount when a draft of this `documentId` newer than the initial
+     * content exists (needs `documentId`):
+     * - `'prompt'` (default): a banner with Restore / Ignore / Remove draft;
+     * - `'auto'`: load the draft straight away, no questions (see `onDraftRestored`);
+     * - `'off'`: keep the initial content; the draft is moved aside into the drafts
+     *   list so new edits don't overwrite it unseen.
+     */
+    restoreDraft?: DraftRestoreMode;
+    /**
+     * What happens when the user is about to leave with unsaved changes, for both
+     * `EditorRef.confirmDiscard()` (in-app navigation, which your router guard
+     * calls) and for closing or refreshing the tab:
+     * - `'confirm'` (default): `confirmDiscard()` opens an in-editor popup (Save /
+     *   Discard / Save draft / Cancel). On closing or refreshing the tab no
+     *   popup is possible, and a draft is saved instead when `autosave` is on, so the
+     *   browser's own "leave this page?" prompt is skipped; it only appears as a last
+     *   resort, when no draft could be stored (autosave off, document over
+     *   `autosaveMaxBytes`, storage unavailable);
+     * - `'save-draft'`: silently saves a draft and lets the user go — no popup, no
+     *   browser prompt. Works even with `autosave={false}`. If the draft can't be
+     *   stored (e.g. the document is over `autosaveMaxBytes`) `confirmDiscard()` falls
+     *   back to the popup, so work is never lost silently;
+     * - `'off'`: no guard; the user is never asked.
+     */
+    navigationGuard?: NavigationGuardMode;
+    /** Called when a saved draft was loaded into the editor (banner Restore, or `restoreDraft="auto"`). */
+    onDraftRestored?: (draft: {
+        documentId: string;
+        savedAt: number;
+    }) => void;
+    /** Debounce delay before writing an autosave draft, in ms. Default `750`. */
+    autosaveDelayMs?: number;
+    /**
+     * Skips (rather than throwing) an autosave write whose JSON would exceed
+     * this size — `localStorage` has a shared ~5-10MB per-origin ceiling, so a
+     * single document with embedded base64 images must not be allowed to
+     * autosave past a sane limit. Default `2_000_000` (~2MB).
+     */
+    autosaveMaxBytes?: number;
+    /**
+     * How many drafts to keep in the browser, across all documents; the oldest
+     * beyond this are deleted as new ones are written (this editor's own draft
+     * is never pruned). Default `20`.
+     */
+    autosaveMaxDrafts?: number;
 }
 export interface EditorRef {
     getContent(format: FormatId): string;

package/dist/EditorRoot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EditorRoot.d.ts","sourceRoot":"","sources":["../src/EditorRoot.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAU1D,OAAO,KAAK,EAAe,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAClE,OAAO,EAAyB,KAAK,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AACvF,OAAO,EAAwB,KAAK,mBAAmB,EAAE,KAAK,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAKzH,OAAO,EAAyB,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAIjE,OAAO,EAAgC,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEnE,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,YAAY,CAAC,CAAC;IACzD,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,oBAAoB,CAAC;IACtC,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC,aAAa,CAAC,EAAE,uBAAuB,CAAC;IACxC,KAAK,CAAC,EAAE,oBAAoB,CAAC;IAC7B,WAAW,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC/B;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC;IAClD;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,KAAK,IAAI,CAAC;IACrD;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAChD;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,SAAS;IACxB,UAAU,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAC;IACrC,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAG,IAAI,CAAC;IAClD,iBAAiB,IAAI,OAAO,CAAC;IAC7B,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IACnC,KAAK,IAAI,IAAI,CAAC;CACf;AAQD,eAAO,MAAM,UAAU,uGAkKrB,CAAC"}
+{"version":3,"file":"EditorRoot.d.ts","sourceRoot":"","sources":["../src/EditorRoot.tsx"],"names":[],"mappings":"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"}

package/dist/EditorRoot.js

@@ -7,6 +7,8 @@ import { HistoryPlugin } from '@lexical/react/LexicalHistoryPlugin';
 import { ListPlugin } from '@lexical/react/LexicalListPlugin';
 import { CheckListPlugin } from '@lexical/react/LexicalCheckListPlugin';
 import { LinkPlugin } from '@lexical/react/LexicalLinkPlugin';
+import { TablePlugin } from '@lexical/react/LexicalTablePlugin';
+import { HorizontalRulePlugin } from '@lexical/react/LexicalHorizontalRulePlugin';
 import { OnChangePlugin } from '@lexical/react/LexicalOnChangePlugin';
 import { LexicalErrorBoundary } from '@lexical/react/LexicalErrorBoundary';
 import { defaultFormatRegistry } from '@inshapardaz/likhari-converters';
@@ -17,19 +19,31 @@ import { EditorThemeProvider } from './theme/EditorThemeProvider.js';
 import { Toolbar } from './components/Toolbar.js';
 import { injectUrduWebFontsCss } from './fonts/index.js';
 import { LinkPastePlugin } from './plugins/LinkPastePlugin.js';
+import { DraftRestore } from './components/DraftRestore.js';
+import { LeaveDialog } from './components/LeaveDialog.js';
+import { clearDraft, createDraftId, hasDraftContent, pruneDrafts, writeDraft, } from './persistence/draftStorage.js';
 import { ImageOptionsContext } from './image/ImageOptionsContext.js';
 import { PortalTargetContext } from './PortalTargetContext.js';
 import { UiStringsContext, getStrings } from './i18n/index.js';
+const DEFAULT_AUTOSAVE_DELAY_MS = 750;
+const DEFAULT_AUTOSAVE_MAX_BYTES = 2000000;
+const DEFAULT_AUTOSAVE_MAX_DRAFTS = 20;
 function initialEditorStateJson(initialContent) {
     if (!initialContent)
         return undefined;
     const state = defaultFormatRegistry.parse(initialContent.format, initialContent.value);
     return JSON.stringify(state);
 }
-export const EditorRoot = forwardRef(function EditorRoot({ documentId, initialContent, featureConfig, featurePreset, theme, colorScheme, accentColor, locale = 'en', placeholder, height = '480px', onChange, onSave, showSave = Boolean(onSave), onImageUpload, fetchImage, fontOptions, }, ref) {
+export const EditorRoot = forwardRef(function EditorRoot({ documentId, initialContent, featureConfig, featurePreset, theme, colorScheme, accentColor, locale = 'en', placeholder, height = '480px', onChange, onSave, showSave = Boolean(onSave), onImageUpload, fetchImage, fontOptions, autosave = true, restoreDraft = 'prompt', navigationGuard = 'confirm', onDraftRestored, autosaveDelayMs = DEFAULT_AUTOSAVE_DELAY_MS, autosaveMaxBytes = DEFAULT_AUTOSAVE_MAX_BYTES, autosaveMaxDrafts = DEFAULT_AUTOSAVE_MAX_DRAFTS, }, ref) {
     const config = useMemo(() => resolveFeatureConfig(featureConfig, featurePreset), [featureConfig, featurePreset]);
     const strings = useMemo(() => getStrings(locale), [locale]);
     const resolvedPlaceholder = placeholder ?? strings.editor.placeholder;
+    // The draft's storage key: the host's documentId, else — so editors without
+    // one never overwrite each other — a unique id generated for this editor (or
+    // the id of an anonymous draft the user restored into it).
+    const [generatedDraftId] = useState(createDraftId);
+    const [adoptedDraftId, setAdoptedDraftId] = useState(null);
+    const draftId = documentId ?? adoptedDraftId ?? generatedDraftId;
     // The urdu-web-fonts stylesheets are needed for the font dropdown and for
     // RTL content, whose canvas font (editor.css) is one of those families.
     useEffect(() => {
@@ -47,17 +61,136 @@ export const EditorRoot = forwardRef(function EditorRoot({ documentId, initialCo
     const editorStateRef = useRef(null);
     const lastSavedJsonRef = useRef(null);
     const [isDirty, setIsDirty] = useState(false);
+    const isDirtyRef = useRef(isDirty);
+    isDirtyRef.current = isDirty;
+    const autosaveTimerRef = useRef(null);
+    // The latest change not yet written, so unload / unmount can flush it.
+    const pendingDraftRef = useRef(null);
+    const flushDraft = () => {
+        if (autosaveTimerRef.current) {
+            clearTimeout(autosaveTimerRef.current);
+            autosaveTimerRef.current = null;
+        }
+        const pending = pendingDraftRef.current;
+        pendingDraftRef.current = null;
+        if (!pending)
+            return;
+        // A document that is blank again isn't worth a draft.
+        if (hasDraftContent(pending.json)) {
+            writeDraft(pending.id, pending.json, autosaveMaxBytes);
+            pruneDrafts(autosaveMaxDrafts, [pending.id]);
+        }
+        else {
+            clearDraft(pending.id);
+        }
+    };
+    const flushDraftRef = useRef(flushDraft);
+    flushDraftRef.current = flushDraft;
+    /** Writes the latest content as a draft now, without waiting out the debounce.
+     * Returns whether it is safely stored (or there was nothing worth storing). */
+    const saveDraftNow = () => {
+        if (autosaveTimerRef.current) {
+            clearTimeout(autosaveTimerRef.current);
+            autosaveTimerRef.current = null;
+        }
+        const latest = editorStateRef.current ? JSON.stringify(editorStateRef.current.toJSON()) : pendingDraftRef.current?.json;
+        pendingDraftRef.current = null;
+        if (!latest)
+            return true;
+        // A blank document isn't worth a draft.
+        if (!hasDraftContent(latest)) {
+            clearDraft(draftId);
+            return true;
+        }
+        const stored = writeDraft(draftId, latest, autosaveMaxBytes);
+        if (stored)
+            pruneDrafts(autosaveMaxDrafts, [draftId]);
+        return stored;
+    };
+    const saveDraftNowRef = useRef(saveDraftNow);
+    saveDraftNowRef.current = saveDraftNow;
+    const navigationGuardRef = useRef(navigationGuard);
+    navigationGuardRef.current = navigationGuard;
+    const autosaveRef = useRef(autosave);
+    autosaveRef.current = autosave;
+    // The in-editor "leave?" popup behind confirmDiscard().
+    const [leavePrompt, setLeavePrompt] = useState(null);
+    const leaveResolveRef = useRef(null);
+    const settleLeave = (canLeave) => {
+        const resolve = leaveResolveRef.current;
+        leaveResolveRef.current = null;
+        setLeavePrompt(null);
+        resolve?.(canLeave);
+    };
+    const askToLeave = (draftFailed = false) => new Promise((resolve) => {
+        leaveResolveRef.current?.(false); // a second call supersedes an unanswered one
+        leaveResolveRef.current = resolve;
+        setLeavePrompt({ draftFailed });
+    });
+    const confirmDiscardImpl = async () => {
+        if (!isDirtyRef.current || navigationGuard === 'off')
+            return true;
+        if (navigationGuard === 'save-draft') {
+            if (saveDraftNow())
+                return true;
+            return askToLeave(true);
+        }
+        return askToLeave();
+    };
+    const confirmDiscardRef = useRef(confirmDiscardImpl);
+    confirmDiscardRef.current = confirmDiscardImpl;
+    // An unanswered popup must not leave a caller's promise hanging if the editor goes away.
+    useEffect(() => () => leaveResolveRef.current?.(false), []);
+    // Computed once, before the first autosave write could possibly run, so
+    // the restore-prompt plugin below can tell a stored draft that's merely
+    // identical to the initial content apart (no prompt needed) from one that
+    // actually represents newer, unsaved work.
+    const initialContentJsonRef = useRef(undefined);
+    if (initialContentJsonRef.current === undefined) {
+        initialContentJsonRef.current = initialEditorStateJson(initialContent);
+    }
     const initialConfig = useMemo(() => ({
         namespace: `likhari-editor-${documentId ?? 'anonymous'}`,
         nodes: EDITOR_NODES,
         theme: editorTheme,
-        editorState: initialEditorStateJson(initialContent),
+        editorState: initialContentJsonRef.current,
         onError(error) {
             throw error;
         },
     }), 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     []);
+    // beforeunload (lexical-editor-spec.md §6.4): the automatic half of the
+    // navigation guard — hasUnsavedChanges()/confirmDiscard() below are the
+    // imperative half a host's own router guard calls for in-app navigation,
+    // which the editor can't intercept on its own.
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const handleBeforeUnload = (event) => {
+            // Write any edit still waiting out the debounce before the page goes.
+            flushDraftRef.current();
+            if (!isDirtyRef.current)
+                return;
+            const guard = navigationGuardRef.current;
+            if (guard === 'off')
+                return;
+            // The work is saved as a draft (restorable from the banner / drafts list
+            // when the page is opened again), so there is nothing to warn about and
+            // the browser's prompt is skipped. It only appears as a last resort, when
+            // no draft could be stored (autosave off, document too large, storage
+            // unavailable) — a page can't customise or replace it, and it is the only
+            // thing between the user and silently losing their work.
+            if ((guard === 'save-draft' || autosaveRef.current) && saveDraftNowRef.current())
+                return;
+            event.preventDefault();
+            event.returnValue = '';
+        };
+        window.addEventListener('beforeunload', handleBeforeUnload);
+        return () => window.removeEventListener('beforeunload', handleBeforeUnload);
+    }, []);
+    // Unmounting (e.g. in-app navigation) also writes what is still pending.
+    useEffect(() => () => flushDraftRef.current(), []);
     useImperativeHandle(ref, () => ({
         getContent(format) {
             if (!editorStateRef.current)
@@ -77,23 +210,35 @@ export const EditorRoot = forwardRef(function EditorRoot({ documentId, initialCo
         hasUnsavedChanges() {
             return isDirty;
         },
-        async confirmDiscard() {
-            if (!isDirty)
-                return true;
-            if (typeof window === 'undefined')
-                return true;
-            return window.confirm(strings.editor.confirmDiscard);
+        confirmDiscard() {
+            return confirmDiscardRef.current();
         },
         focus() {
             rootElementRef.current?.focus();
         },
-    }), [isDirty, strings]);
+    }), [isDirty]);
     const rootElementRef = useRef(null);
     const handleChange = (state) => {
         editorStateRef.current = state;
         const json = JSON.stringify(state.toJSON());
         setIsDirty(json !== lastSavedJsonRef.current);
         onChange?.(state.toJSON());
+        if (autosave) {
+            pendingDraftRef.current = { id: draftId, json };
+            if (autosaveTimerRef.current)
+                clearTimeout(autosaveTimerRef.current);
+            autosaveTimerRef.current = setTimeout(flushDraft, autosaveDelayMs);
+        }
+    };
+    /** A draft was restored into the editor: that content is unsaved work. */
+    const handleDraftRestored = (entry) => {
+        setIsDirty(true);
+        if (documentId && entry.id === documentId)
+            onDraftRestored?.({ documentId, savedAt: entry.draft.savedAt });
+        // Without a documentId the restored draft becomes this editor's own, so
+        // later edits update it instead of piling up copies.
+        if (!documentId)
+            setAdoptedDraftId(entry.id);
     };
     const handleSave = () => {
         if (!editorStateRef.current)
@@ -103,6 +248,15 @@ export const EditorRoot = forwardRef(function EditorRoot({ documentId, initialCo
         const content = defaultFormatRegistry.serialize(format, json);
         lastSavedJsonRef.current = JSON.stringify(json);
         setIsDirty(false);
+        // A successful explicit save supersedes any in-progress/queued autosave
+        // draft — don't let a stale one linger and falsely prompt to "restore"
+        // older content next time this document is opened (§6.2).
+        if (autosaveTimerRef.current) {
+            clearTimeout(autosaveTimerRef.current);
+            autosaveTimerRef.current = null;
+        }
+        pendingDraftRef.current = null;
+        clearDraft(draftId);
         onSave?.(content, format);
     };
     const dir = locale === 'en' ? 'ltr' : 'rtl';
@@ -111,5 +265,24 @@ export const EditorRoot = forwardRef(function EditorRoot({ documentId, initialCo
     // rather than colliding on a shared one.
     const portalTargetId = useId();
     const portalTargetSelector = `#${CSS.escape(portalTargetId)}`;
-    return (_jsx(EditorThemeProvider, { theme: theme, colorScheme: colorScheme, accentColor: accentColor, scopeElementId: portalTargetId, children: _jsxs("div", { className: "likhari-root", dir: dir, ref: rootElementRef, "data-document-id": documentId, style: { height: typeof height === 'number' ? `${height}px` : height }, children: [_jsx("div", { id: portalTargetId, className: "likhari-portal-target" }), _jsx(PortalTargetContext.Provider, { value: portalTargetSelector, children: _jsx(UiStringsContext.Provider, { value: strings, children: _jsx(ImageOptionsContext.Provider, { value: imageOptions, children: _jsxs(LexicalComposer, { initialConfig: initialConfig, children: [_jsx(Toolbar, { config: config, onSave: handleSave, isDirty: isDirty, showSave: showSave, fontOptions: fontOptions, direction: dir, locale: locale }), _jsx("div", { className: "likhari-canvas", children: _jsx(RichTextPlugin, { contentEditable: _jsx(ContentEditable, { className: "likhari-content-editable", dir: dir, "aria-label": strings.editor.contentLabel }), placeholder: _jsx("div", { className: "likhari-placeholder", children: resolvedPlaceholder }), ErrorBoundary: LexicalErrorBoundary }) }), config.history && _jsx(HistoryPlugin, {}), (config.lists.bullet || config.lists.numbered || config.lists.check) && _jsx(ListPlugin, {}), config.lists.check && _jsx(CheckListPlugin, {}), config.links && _jsx(LinkPlugin, {}), config.links && _jsx(LinkPastePlugin, {}), _jsx(OnChangePlugin, { onChange: handleChange })] }) }) }) })] }) }));
+    return (_jsx(EditorThemeProvider, { theme: theme, colorScheme: colorScheme, accentColor: accentColor, scopeElementId: portalTargetId, children: _jsxs("div", { className: "likhari-root", dir: dir, ref: rootElementRef, "data-document-id": documentId, style: { height: typeof height === 'number' ? `${height}px` : height }, children: [_jsx("div", { id: portalTargetId, className: "likhari-portal-target" }), _jsx(PortalTargetContext.Provider, { value: portalTargetSelector, children: _jsxs(UiStringsContext.Provider, { value: strings, children: [_jsx(ImageOptionsContext.Provider, { value: imageOptions, children: _jsxs(LexicalComposer, { initialConfig: initialConfig, children: [_jsx(Toolbar, { config: config, onSave: handleSave, isDirty: isDirty, showSave: showSave, fontOptions: fontOptions, direction: dir, locale: locale, drafts: autosave
+                                                ? { currentId: draftId, maxBytes: autosaveMaxBytes, adoptOnRestore: !documentId, onRestored: handleDraftRestored }
+                                                : undefined }), documentId && (_jsx(DraftRestore, { draftId: documentId, mode: restoreDraft, initialJson: initialContentJsonRef.current, locale: locale, onRestored: handleDraftRestored })), _jsx("div", { className: "likhari-canvas", children: _jsx(RichTextPlugin, { contentEditable: _jsx(ContentEditable, { className: "likhari-content-editable", dir: dir, "aria-label": strings.editor.contentLabel }), placeholder: _jsx("div", { className: "likhari-placeholder", children: resolvedPlaceholder }), ErrorBoundary: LexicalErrorBoundary }) }), config.history && _jsx(HistoryPlugin, {}), (config.lists.bullet || config.lists.numbered || config.lists.check) && _jsx(ListPlugin, {}), config.lists.check && _jsx(CheckListPlugin, {}), config.links && _jsx(LinkPlugin, {}), config.links && _jsx(LinkPastePlugin, {}), config.tables && _jsx(TablePlugin, { hasCellMerge: false, hasTabHandler: true }), config.blocks.horizontalRule && _jsx(HorizontalRulePlugin, {}), _jsx(OnChangePlugin, { onChange: handleChange })] }) }), _jsx(LeaveDialog, { opened: leavePrompt !== null, canSave: Boolean(onSave), canSaveDraft: autosave || navigationGuard === 'save-draft', draftFailed: leavePrompt?.draftFailed ?? false, onSave: () => {
+                                    handleSave();
+                                    settleLeave(true);
+                                }, onSaveDraft: () => {
+                                    if (saveDraftNow())
+                                        settleLeave(true);
+                                    else
+                                        setLeavePrompt({ draftFailed: true });
+                                }, onDiscard: () => {
+                                    // The user chose to drop this work, so no draft of it should linger either.
+                                    if (autosaveTimerRef.current) {
+                                        clearTimeout(autosaveTimerRef.current);
+                                        autosaveTimerRef.current = null;
+                                    }
+                                    pendingDraftRef.current = null;
+                                    clearDraft(draftId);
+                                    settleLeave(true);
+                                }, onCancel: () => settleLeave(false) })] }) })] }) }));
 });

package/dist/components/DraftRestore.d.ts

@@ -0,0 +1,24 @@
+import { type DraftEntry } from '../persistence/draftStorage.js';
+import type { Locale } from '../i18n/index.js';
+/** What to do on mount with a stored draft of this document that is newer than the initial content. */
+export type DraftRestoreMode = 'prompt' | 'auto' | 'off';
+export interface DraftRestoreProps {
+    /** The host's `documentId` — the key the draft is stored under. */
+    draftId: string;
+    mode: DraftRestoreMode;
+    /** The Lexical JSON the editor started with; a draft identical to it isn't offered. */
+    initialJson?: string;
+    locale: Locale;
+    onRestored: (entry: DraftEntry) => void;
+}
+/**
+ * On mount, handles a draft of this document newer than the initial content
+ * (lexical-editor-spec.md §6.2), per `mode`:
+ * - `prompt` (default): a banner — Restore, Ignore (kept in the drafts list,
+ *   since new edits would otherwise overwrite it) or Remove. Never picks silently.
+ * - `auto`: loads the draft straight away, no banner.
+ * - `off`: leaves the editor on its initial content, but moves the draft aside
+ *   as an earlier version so new edits can't overwrite it unseen.
+ */
+export declare function DraftRestore({ draftId, mode, initialJson, locale, onRestored }: DraftRestoreProps): import("react").JSX.Element | null;
+//# sourceMappingURL=DraftRestore.d.ts.map

package/dist/components/DraftRestore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DraftRestore.d.ts","sourceRoot":"","sources":["../../src/components/DraftRestore.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAwD,KAAK,UAAU,EAAoB,MAAM,6BAA6B,CAAC;AAGtI,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEtC,uGAAuG;AACvG,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC;AAEzD,MAAM,WAAW,iBAAiB;IAChC,mEAAmE;IACnE,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,gBAAgB,CAAC;IACvB,uFAAuF;IACvF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;CACzC;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,EAAE,iBAAiB,sCA8DjG"}

package/dist/components/DraftRestore.js

@@ -0,0 +1,61 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { IconHistory } from '@tabler/icons-react';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { archiveDraft, clearDraft, hasDraftContent, readDraft } from '../persistence/draftStorage.js';
+import { applyDraftToEditor, formatDraftTime } from '../persistence/draftUi.js';
+import { useUiStrings } from '../i18n/useStrings.js';
+/**
+ * On mount, handles a draft of this document newer than the initial content
+ * (lexical-editor-spec.md §6.2), per `mode`:
+ * - `prompt` (default): a banner — Restore, Ignore (kept in the drafts list,
+ *   since new edits would otherwise overwrite it) or Remove. Never picks silently.
+ * - `auto`: loads the draft straight away, no banner.
+ * - `off`: leaves the editor on its initial content, but moves the draft aside
+ *   as an earlier version so new edits can't overwrite it unseen.
+ */
+export function DraftRestore({ draftId, mode, initialJson, locale, onRestored }) {
+    const [editor] = useLexicalComposerContext();
+    const strings = useUiStrings();
+    const [draft, setDraft] = useState(() => {
+        const stored = readDraft(draftId);
+        return stored && hasDraftContent(stored.json) && stored.json !== initialJson ? stored : null;
+    });
+    const handled = useRef(false);
+    const restore = () => {
+        if (!draft)
+            return;
+        if (applyDraftToEditor(editor, draft.json))
+            onRestored({ id: draftId, draft });
+        // A corrupt or incompatible draft can't be restored: drop the banner and keep the initial content.
+        setDraft(null);
+    };
+    const ignore = () => {
+        // Move it aside, so edits from here on can't overwrite it unseen.
+        if (archiveDraft(draftId))
+            clearDraft(draftId);
+        setDraft(null);
+    };
+    // Non-interactive modes act once, on mount.
+    useEffect(() => {
+        if (handled.current || !draft)
+            return;
+        handled.current = true;
+        if (mode === 'auto')
+            restore();
+        else if (mode === 'off')
+            ignore();
+        // Deliberately runs once on mount only.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const remove = () => {
+        clearDraft(draftId);
+        setDraft(null);
+    };
+    if (!draft || mode !== 'prompt')
+        return null;
+    // Plain elements styled with the editor's own tokens (editor.css): Mantine's
+    // theme variables are scoped to the portal target, so an in-flow Mantine
+    // button here would fall back to Mantine's default blue.
+    return (_jsxs("div", { className: "likhari-draft-banner", role: "status", "aria-live": "polite", children: [_jsxs("div", { className: "likhari-draft-banner-message", children: [_jsx(IconHistory, { size: 18, stroke: 1.75, "aria-hidden": "true" }), _jsx("span", { children: strings.drafts.bannerMessage(formatDraftTime(draft.savedAt, locale)) })] }), _jsxs("div", { className: "likhari-draft-banner-actions", children: [_jsx("button", { type: "button", className: "likhari-draft-banner-button", "data-variant": "primary", onClick: restore, children: strings.drafts.restore }), _jsx("button", { type: "button", className: "likhari-draft-banner-button", onClick: ignore, children: strings.drafts.ignore }), _jsx("button", { type: "button", className: "likhari-draft-banner-button", "data-variant": "danger", onClick: remove, children: strings.drafts.remove })] })] }));
+}

package/dist/components/DraftsDialog.d.ts

@@ -0,0 +1,25 @@
+import { type DraftEntry } from '../persistence/draftStorage.js';
+import type { Locale } from '../i18n/index.js';
+/** What the toolbar needs to offer the drafts list. */
+export interface DraftsToolbarOptions {
+    /** The key this editor's own autosave writes to. */
+    currentId: string;
+    /** Size cap for archiving the content a restore replaces. */
+    maxBytes: number;
+    /** Without a `documentId`, a restored draft becomes this editor's draft, so later edits update it instead of duplicating it. */
+    adoptOnRestore: boolean;
+    onRestored: (entry: DraftEntry) => void;
+}
+export interface DraftsDialogProps extends DraftsToolbarOptions {
+    opened: boolean;
+    locale: Locale;
+    onClose: () => void;
+}
+/**
+ * Every autosaved draft in this browser (all documents, and the earlier
+ * versions kept when a restore prompt was ignored), newest first, each with
+ * Restore and Delete. Restoring over content that differs asks first, and keeps
+ * the replaced content as a draft of its own, so nothing is lost either way.
+ */
+export declare function DraftsDialog({ opened, locale, currentId, maxBytes, adoptOnRestore, onRestored, onClose }: DraftsDialogProps): import("react").JSX.Element;
+//# sourceMappingURL=DraftsDialog.d.ts.map

package/dist/components/DraftsDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DraftsDialog.d.ts","sourceRoot":"","sources":["../../src/components/DraftsDialog.tsx"],"names":[],"mappings":"AAGA,OAAO,EAOL,KAAK,UAAU,EAChB,MAAM,6BAA6B,CAAC;AAIrC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEtC,uDAAuD;AACvD,MAAM,WAAW,oBAAoB;IACnC,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,QAAQ,EAAE,MAAM,CAAC;IACjB,gIAAgI;IAChI,cAAc,EAAE,OAAO,CAAC;IACxB,UAAU,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;CACzC;AAED,MAAM,WAAW,iBAAkB,SAAQ,oBAAoB;IAC7D,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAID;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,cAAc,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE,iBAAiB,+BAmH3H"}

package/dist/components/DraftsDialog.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { Badge, Button, Group, Modal, Paper, Stack, Text } from '@mantine/core';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { clearDraft, createDraftId, hasDraftContent, isGeneratedDraftId, listDrafts, writeDraft, } from '../persistence/draftStorage.js';
+import { applyDraftToEditor, formatDraftTime } from '../persistence/draftUi.js';
+import { useUiStrings } from '../i18n/useStrings.js';
+import { usePortalTarget } from '../PortalTargetContext.js';
+/**
+ * Every autosaved draft in this browser (all documents, and the earlier
+ * versions kept when a restore prompt was ignored), newest first, each with
+ * Restore and Delete. Restoring over content that differs asks first, and keeps
+ * the replaced content as a draft of its own, so nothing is lost either way.
+ */
+export function DraftsDialog({ opened, locale, currentId, maxBytes, adoptOnRestore, onRestored, onClose }) {
+    const [editor] = useLexicalComposerContext();
+    const strings = useUiStrings();
+    const portalTarget = usePortalTarget();
+    const [entries, setEntries] = useState([]);
+    const [pending, setPending] = useState(null);
+    useEffect(() => {
+        if (opened) {
+            setEntries(listDrafts());
+            setPending(null);
+        }
+    }, [opened]);
+    const currentJson = () => JSON.stringify(editor.getEditorState().toJSON());
+    const restore = (entry) => {
+        const before = currentJson();
+        // Keep what is being replaced, as a draft of its own.
+        if (before !== entry.draft.json && hasDraftContent(before)) {
+            writeDraft(createDraftId(), before, maxBytes, currentId);
+            if (adoptOnRestore)
+                clearDraft(currentId);
+        }
+        if (applyDraftToEditor(editor, entry.draft.json)) {
+            onRestored(entry);
+            onClose();
+        }
+    };
+    const requestRestore = (entry) => {
+        const before = currentJson();
+        // Replacing real, different content is confirmed first (inline, not a window.confirm).
+        if (before !== entry.draft.json && hasDraftContent(before))
+            setPending({ id: entry.id, action: 'restore' });
+        else
+            restore(entry);
+    };
+    const remove = (entry) => {
+        clearDraft(entry.id);
+        setEntries(listDrafts());
+        setPending(null);
+    };
+    const label = (entry) => {
+        const source = entry.draft.sourceId;
+        if (source)
+            return isGeneratedDraftId(source) ? strings.drafts.earlierUntitled : strings.drafts.earlierVersionOf(source);
+        return isGeneratedDraftId(entry.id) ? strings.drafts.untitled : strings.drafts.documentLabel(entry.id);
+    };
+    return (_jsx(Modal, { opened: opened, onClose: onClose, title: strings.drafts.dialogTitle, centered: true, size: "lg", portalProps: portalTarget ? { target: portalTarget } : undefined, children: _jsxs(Stack, { gap: "sm", children: [_jsx(Text, { size: "sm", c: "dimmed", children: strings.drafts.intro }), entries.length === 0 && _jsx(Text, { size: "sm", children: strings.drafts.empty }), entries.map((entry) => {
+                    const isCurrent = entry.id === currentId;
+                    const isPending = pending?.id === entry.id;
+                    return (_jsx(Paper, { withBorder: true, p: "sm", radius: "sm", "data-draft-id": entry.id, children: _jsxs(Stack, { gap: 6, children: [_jsxs(Group, { justify: "space-between", wrap: "nowrap", align: "flex-start", children: [_jsx(Text, { size: "sm", lineClamp: 2, style: { flex: 1, wordBreak: 'break-word' }, children: entry.draft.preview || strings.drafts.noText }), isCurrent && _jsx(Badge, { variant: "light", children: strings.drafts.thisDocument })] }), _jsxs(Text, { size: "xs", c: "dimmed", children: [label(entry), " \u00B7 ", strings.drafts.savedAt(formatDraftTime(entry.draft.savedAt, locale)), " \u00B7", ' ', strings.drafts.size(Math.max(1, Math.round(entry.draft.json.length / 1024)))] }), !isCurrent &&
+                                    (isPending ? (_jsxs(Group, { gap: "xs", align: "center", children: [_jsx(Text, { size: "sm", children: pending.action === 'restore' ? strings.drafts.replacePrompt : strings.drafts.deletePrompt }), _jsx(Button, { size: "compact-sm", color: pending.action === 'delete' ? 'red' : undefined, onClick: () => (pending.action === 'restore' ? restore(entry) : remove(entry)), children: pending.action === 'restore' ? strings.drafts.replace : strings.drafts.delete }), _jsx(Button, { size: "compact-sm", variant: "default", onClick: () => setPending(null), children: strings.common.cancel })] })) : (_jsxs(Group, { gap: "xs", children: [_jsx(Button, { size: "compact-sm", onClick: () => requestRestore(entry), children: strings.drafts.restore }), _jsx(Button, { size: "compact-sm", variant: "subtle", color: "red", onClick: () => setPending({ id: entry.id, action: 'delete' }), children: strings.drafts.delete })] })))] }) }, entry.id));
+                }), _jsx(Group, { justify: "flex-end", children: _jsx(Button, { variant: "default", onClick: onClose, children: strings.drafts.close }) })] }) }));
+}

package/dist/components/LeaveDialog.d.ts

@@ -0,0 +1,22 @@
+export interface LeaveDialogProps {
+    opened: boolean;
+    /** Offer "Save" (calls the host's `onSave`, then lets the user leave). */
+    canSave: boolean;
+    /** Offer "Save draft" (keeps the work in this browser, then lets the user leave). */
+    canSaveDraft: boolean;
+    /** A "Save draft" attempt failed; explains why the dialog is still open. */
+    draftFailed: boolean;
+    onSave: () => void;
+    onSaveDraft: () => void;
+    onDiscard: () => void;
+    /** Cancel: stay on the page. Escape, the close button and clicking outside do the same. */
+    onCancel: () => void;
+}
+/**
+ * The in-editor popup behind `EditorRef.confirmDiscard()`: what to do with
+ * unsaved changes before leaving. It replaces `window.confirm()`, which can't
+ * be styled, translated per editor, or offer more than OK/Cancel. (The browser's
+ * own tab-close prompt can't be replaced — see `navigationGuard`.)
+ */
+export declare function LeaveDialog({ opened, canSave, canSaveDraft, draftFailed, onSave, onSaveDraft, onDiscard, onCancel }: LeaveDialogProps): import("react").JSX.Element;
+//# sourceMappingURL=LeaveDialog.d.ts.map

package/dist/components/LeaveDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LeaveDialog.d.ts","sourceRoot":"","sources":["../../src/components/LeaveDialog.tsx"],"names":[],"mappings":"AAIA,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,CAAC;IAChB,0EAA0E;IAC1E,OAAO,EAAE,OAAO,CAAC;IACjB,qFAAqF;IACrF,YAAY,EAAE,OAAO,CAAC;IACtB,4EAA4E;IAC5E,WAAW,EAAE,OAAO,CAAC;IACrB,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,WAAW,EAAE,MAAM,IAAI,CAAC;IACxB,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,2FAA2F;IAC3F,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAE,gBAAgB,+BAyCrI"}

package/dist/components/LeaveDialog.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Alert, Button, Group, Modal, Stack, Text } from '@mantine/core';
+import { useUiStrings } from '../i18n/useStrings.js';
+import { usePortalTarget } from '../PortalTargetContext.js';
+/**
+ * The in-editor popup behind `EditorRef.confirmDiscard()`: what to do with
+ * unsaved changes before leaving. It replaces `window.confirm()`, which can't
+ * be styled, translated per editor, or offer more than OK/Cancel. (The browser's
+ * own tab-close prompt can't be replaced — see `navigationGuard`.)
+ */
+export function LeaveDialog({ opened, canSave, canSaveDraft, draftFailed, onSave, onSaveDraft, onDiscard, onCancel }) {
+    const strings = useUiStrings();
+    const portalTarget = usePortalTarget();
+    return (_jsx(Modal, { opened: opened, onClose: onCancel, title: strings.leaveDialog.title, centered: true, size: "lg", portalProps: portalTarget ? { target: portalTarget } : undefined, children: _jsxs(Stack, { gap: "md", children: [_jsx(Text, { size: "sm", children: strings.leaveDialog.message }), draftFailed && (_jsx(Alert, { color: "red", variant: "light", p: "xs", children: strings.leaveDialog.saveDraftFailed })), _jsxs(Group, { justify: "flex-end", gap: "xs", wrap: "nowrap", children: [canSave && (_jsx(Button, { size: "sm", onClick: onSave, children: strings.leaveDialog.save })), _jsx(Button, { size: "sm", variant: "outline", color: "red", onClick: onDiscard, children: strings.leaveDialog.discard }), canSaveDraft && (_jsx(Button, { size: "sm", variant: "default", onClick: onSaveDraft, children: strings.leaveDialog.saveDraft })), _jsx(Button, { size: "sm", variant: "default", onClick: onCancel, "data-autofocus": true, children: strings.common.cancel })] })] }) }));
+}

package/dist/components/TableDialog.d.ts

@@ -0,0 +1,17 @@
+export interface TableDialogValue {
+    rows: number;
+    columns: number;
+    headerRow: boolean;
+}
+export interface TableDialogProps {
+    opened: boolean;
+    onSubmit: (value: TableDialogValue) => void;
+    onClose: () => void;
+}
+/**
+ * Insert-table dialog: rows x columns and an optional header row. Cell
+ * merge/split is intentionally not offered anywhere in this dialog or the
+ * table it creates — see the comment on `TablePlugin` in `EditorRoot.tsx`.
+ */
+export declare function TableDialog({ opened, onSubmit, onClose }: TableDialogProps): import("react").JSX.Element;
+//# sourceMappingURL=TableDialog.d.ts.map

package/dist/components/TableDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TableDialog.d.ts","sourceRoot":"","sources":["../../src/components/TableDialog.tsx"],"names":[],"mappings":"AAKA,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC5C,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAOD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,gBAAgB,+BAiD1E"}