diff --git a/README.md b/README.md
index 3ef187a..922aff5 100644
--- a/README.md
+++ b/README.md
@@ -30,7 +30,8 @@ EdenText is a web-based, powerful word processor for everything from quick notes
> EdenText is young, in **beta** and actively developed — more features are on
> the way. It is tested — the full suite plus LibreOffice round-trip checks run
> on every commit — but expect occasional bugs, and keep backups of documents
-> you care about.
+> you care about. The browser copy also keeps the last three versions of the open
+> document — File ▸ Earlier versions puts one back.
[](https://edentext.app)
Sample File from https://sample-files.com/
diff --git a/src/App.svelte b/src/App.svelte
index 4a63c32..9f3beb5 100644
--- a/src/App.svelte
+++ b/src/App.svelte
@@ -46,6 +46,7 @@
import { loadLineNumbering, saveLineNumbering, DEFAULT_LINE_NUMBERING, type LineNumbering } from './lib/storage/lineNumbering';
import { loadFoldMarks, saveFoldMarks } from './lib/storage/foldMarks';
import { printMarkup } from './lib/storage/printMarkup.svelte';
+ import { snapshots, loadSnapshots, readSnapshot } from './lib/storage/snapshots.svelte';
import { commentsInPane, changesInPane, markupAttrs, setShowChanges, setShowComments } from './lib/storage/markup.svelte';
import { loadDocumentLanguage, saveDocumentLanguage, odfFromLanguage, type DocumentLanguage } from './lib/storage/documentLanguage';
import { setTableLanguage } from './lib/storage/tableOptions.svelte';
@@ -68,7 +69,7 @@
import { OPEN_THESAURUS_EVENT } from './lib/spell/thesaurus';
import StyleManagerDialog from './lib/components/StyleManagerDialog.svelte';
import NoteOptionsDialog from './lib/components/NoteOptionsDialog.svelte';
- import { t } from './lib/i18n/i18n.svelte';
+ import { t, locale } from './lib/i18n/i18n.svelte';
import { withShortcut } from './lib/i18n/shortcut';
import { DEFAULT_SHORTCUTS, matchesEvent, shortcutHint } from './lib/editor/shortcuts';
import { OPEN_LINK_DIALOG_EVENT } from './lib/editor/extensions/link';
@@ -1040,6 +1041,29 @@
}
}
+ // The versions the autosave keeps aside, and the reader's label for one.
+ void loadSnapshots();
+ function snapshotLabel(at: number): string {
+ return new Date(at).toLocaleString(locale(), { dateStyle: 'short', timeStyle: 'short' });
+ }
+
+ // Put an earlier version's text back. The page setup, the styles and the zones
+ // belong to the open document, so only the text is replaced.
+ async function handleRestoreSnapshot(at: number) {
+ exportMenuOpen = false;
+ if (!editor || !confirm(t().dialogs.confirmRestore(snapshotLabel(at)))) return;
+ const json = await readSnapshot(at);
+ if (!json) {
+ alert(t().dialogs.snapshotGone);
+ void loadSnapshots();
+ return;
+ }
+ loadContent(json as Content);
+ documentEpoch++;
+ resetHistory();
+ editor.commands.focus();
+ }
+
function handleForgetRecent() {
forgetRecentFiles();
recentFiles = [];
@@ -1317,6 +1341,8 @@
recentFiles={recentFiles}
onOpenRecent={(id) => { const f = recentFiles.find((r) => r.id === id); if (f) void handleOpenRecent(f); }}
onForgetRecent={handleForgetRecent}
+ snapshots={snapshots().map((at) => ({ at, label: snapshotLabel(at) }))}
+ onRestoreSnapshot={(at) => void handleRestoreSnapshot(at)}
onExportPdf={handleExportPdf}
onPrintPdf={handlePrintPdf}
onPrint={handlePrint}
@@ -1454,6 +1480,14 @@
{t().app.clearRecentFiles}
{/if}
+ {#if snapshots().length}
+ {t().app.versions}
+ {#each snapshots() as at (at)}
+ handleRestoreSnapshot(at)} role="menuitem">
+ {snapshotLabel(at)}
+
+ {/each}
+ {/if}
{ exportMenuOpen = false; passwordSetOpen = true; }} role="menuitem">
{t().password.menu}
{#if docProtected}{t().password.menuOn} {/if}
diff --git a/src/lib/components/ribbon/Ribbon.svelte b/src/lib/components/ribbon/Ribbon.svelte
index 1b61744..4dd0d61 100644
--- a/src/lib/components/ribbon/Ribbon.svelte
+++ b/src/lib/components/ribbon/Ribbon.svelte
@@ -72,7 +72,7 @@
hasPassword = false,
onNew, onNewFromTemplate, onOpen, onSave, onSaveAs, onSaveDocx, onSaveTemplate, onExportPdf, onPrintPdf, onPrint, onAbout, onDocProperties, onProtect, onAutoCorrect, onAutoText, onNewComment,
navigatorOpen = false, onToggleNavigator,
- recentFiles = [], onOpenRecent, onForgetRecent,
+ recentFiles = [], onOpenRecent, onForgetRecent, snapshots = [], onRestoreSnapshot,
}: {
editor: Editor | null;
tick: number;
@@ -118,6 +118,8 @@
onSaveDocx?: () => void;
onSaveTemplate?: () => void;
recentFiles?: { id: string; name: string }[];
+ snapshots?: { at: number; label: string }[];
+ onRestoreSnapshot?: (at: number) => void;
onOpenRecent?: (id: string) => void;
onForgetRecent?: () => void;
onExportPdf?: () => void;
@@ -248,6 +250,15 @@
{/if}
+ {#if snapshots.length}
+ { closeMenu(); onRestoreSnapshot?.(s.at); }}>
+
+ {/each}
+ {/if}
run(onPrint)} disabled={!editor || pdfBusy}>
` before the write and keeps the bytes in the `edentext-images` IndexedDB store (a handful of photos is the whole localStorage quota). The key is a content hash of the data-URI's head, tail and length — sampled, because this runs on every autosave — so a picture used twice is stored once, and each save sweeps the keys the document no longer names. Where IndexedDB is unavailable the data-URIs stay inline, exactly as before; a key the store has lost keeps its `idb:` src and is reported, rather than quietly dropping the reader's content. `loadDocument` is therefore **async**, and `Editor.svelte` awaits it before building the editor.
+- **Earlier versions:** the `edentext-snapshots` IndexedDB store (`snapshots.svelte.ts`) — up to three earlier autosaves, one taken at most every five minutes, keyed by their timestamp. They hold the document **whole**, pictures inline: the image store is swept against the open document, so an older version could not point into it. Both file menus list them; restoring puts only the **text** back, since the page setup, the styles and the zones belong to the open document. A reactive singleton, so the list a menu shows is the one the last autosave wrote.
- **Recent files:** `edentext-recent-files` — `{id, name, at}` per entry, newest first, eight kept (`recentFiles.ts`). Only the label lives here: the `FileSystemFileHandle` that reopens one is structured-cloneable but not JSON, so it sits in the `edentext-recent` IndexedDB store under the same id, and each write sweeps the handles no entry names. Two handles compare only through `isSameEntry`, which is async — hence the walk when recording a file already in the list. A file without a handle is never recorded (nothing could reopen it — no File System Access API, or a template), so the list simply stays empty in Firefox/Safari/Brave; a startup prune drops entries whose handle is gone. Reopening asks for `read` permission again (the API drops it on reload) — a declined prompt keeps the entry for the next try, only a moved or deleted file drops it (with a message). Save re-prompts for write on its own (Save-As fallback in `App.svelte`).
- **Document protected:** `edentext-doc-protected` — `'1'` while the open document is password-protected; the password itself is never stored, so after a reload the first save asks for it again or lets the protection go (`documentName.ts`).
- **Document format:** `edentext-doc-format` — `'docx'` while the open document round-trips as .docx; absent = .odt (`documentName.ts`). Set by the format a file was opened in, and by the extension picked in Save As.
diff --git a/src/lib/storage/autosave.ts b/src/lib/storage/autosave.ts
index 03f6b92..2248a24 100644
--- a/src/lib/storage/autosave.ts
+++ b/src/lib/storage/autosave.ts
@@ -1,5 +1,6 @@
import { t } from '../i18n/i18n.svelte';
import { stashImages, putImages, restoreImages } from './imageStore';
+import { keepSnapshot } from './snapshots.svelte';
const STORAGE_KEY = 'edentext-doc';
// Set while a stored document is being handed to the editor, cleared once the editor
@@ -36,6 +37,9 @@ async function write(): Promise {
const { json: slim, blobs } = stashImages(json);
const stashed = await putImages(blobs);
store(stashed ? slim : json);
+ // Every few minutes one version is kept whole, pictures included — the store the
+ // localStorage copy is swept against holds only what the open document still uses.
+ void keepSnapshot(json);
// Pending until stored, so a flush during the round trip still has it; a newer
// document handed in meanwhile stays pending for the write queued behind.
if (pending === json) pending = null;
diff --git a/src/lib/storage/snapshots.svelte.ts b/src/lib/storage/snapshots.svelte.ts
new file mode 100644
index 0000000..3a3e6d7
--- /dev/null
+++ b/src/lib/storage/snapshots.svelte.ts
@@ -0,0 +1,58 @@
+import { openDb, idbRequest } from './idb';
+
+// Earlier versions of the autosaved document, in IndexedDB. The browser copy is one
+// document deep: a bad edit, a failed load or a swept picture would otherwise take it
+// with no way back. A snapshot holds the document's text — margins, styles and the
+// header/footer belong to the open document and are left where they are.
+const DB_NAME = 'edentext-snapshots';
+const STORE = 'snapshots';
+// Three is what a session is worth; each holds the pictures inline, unlike the
+// localStorage copy, so the store pays for them.
+const KEEP = 3;
+const EVERY_MS = 5 * 60_000;
+
+let list = $state([]);
+let lastAt = 0;
+
+/** When each kept version was taken, newest first. */
+export function snapshots(): number[] {
+ return list;
+}
+
+async function withDb(run: (db: IDBDatabase) => Promise): Promise {
+ if (typeof indexedDB === 'undefined') return null;
+ try {
+ const db = await openDb(DB_NAME, STORE);
+ const out = await run(db);
+ db.close();
+ return out;
+ } catch {
+ return null;
+ }
+}
+
+function keys(db: IDBDatabase): Promise {
+ return idbRequest(db, STORE, 'readonly', (s) => s.getAllKeys());
+}
+
+/** Take one, at most every EVERY_MS, and drop everything past the newest KEEP. */
+export async function keepSnapshot(json: object): Promise {
+ const at = Date.now();
+ if (at - lastAt < EVERY_MS) return;
+ lastAt = at;
+ await withDb(async (db) => {
+ await idbRequest(db, STORE, 'readwrite', (s) => s.put(json, at));
+ const all = (await keys(db)).map(Number).sort((a, b) => b - a);
+ for (const old of all.slice(KEEP)) await idbRequest(db, STORE, 'readwrite', (s) => s.delete(old));
+ list = all.slice(0, KEEP);
+ });
+}
+
+export async function loadSnapshots(): Promise {
+ await withDb(async (db) => { list = (await keys(db)).map(Number).sort((a, b) => b - a); });
+}
+
+export async function readSnapshot(at: number): Promise {
+ return withDb((db) => idbRequest(db, STORE, 'readonly', (s) => s.get(at)))
+ .then((doc) => doc ?? null);
+}
diff --git a/tests/unit/snapshots.test.ts b/tests/unit/snapshots.test.ts
new file mode 100644
index 0000000..2324596
--- /dev/null
+++ b/tests/unit/snapshots.test.ts
@@ -0,0 +1,54 @@
+import { describe, it, expect, vi } from 'vitest';
+
+// A two-call IndexedDB in memory — what openDb/idbRequest (storage/idb.ts) ask for.
+function fakeIndexedDb() {
+ const data = new Map();
+ const req = (result: unknown) => {
+ const r: Record = { result };
+ queueMicrotask(() => (r.onsuccess as (() => void) | undefined)?.());
+ return r;
+ };
+ const store = {
+ put: (v: unknown, k: number) => { data.set(k, v); return req(undefined); },
+ get: (k: number) => req(data.get(k)),
+ getAllKeys: () => req([...data.keys()]),
+ delete: (k: number) => { data.delete(k); return req(undefined); },
+ };
+ const db = { transaction: () => ({ objectStore: () => store }), createObjectStore: () => {}, close: () => {} };
+ return {
+ data,
+ open: () => {
+ const r: Record = { result: db };
+ queueMicrotask(() => {
+ (r.onupgradeneeded as (() => void) | undefined)?.();
+ (r.onsuccess as (() => void) | undefined)?.();
+ });
+ return r;
+ },
+ };
+}
+
+describe('the autosave keeps a few earlier versions', () => {
+ it('takes one every few minutes and holds on to the newest three', async () => {
+ const idb = fakeIndexedDb();
+ vi.stubGlobal('indexedDB', { open: idb.open });
+ const { keepSnapshot, snapshots, readSnapshot } = await import('../../src/lib/storage/snapshots.svelte');
+ const now = vi.spyOn(Date, 'now');
+ const at = (min: number) => 1_800_000_000_000 + min * 60_000;
+
+ now.mockReturnValue(at(0));
+ await keepSnapshot({ type: 'doc', v: 1 });
+ now.mockReturnValue(at(1));
+ await keepSnapshot({ type: 'doc', v: 2 }); // a minute on: still the same version
+ expect(snapshots()).toEqual([at(0)]);
+
+ for (const m of [6, 12, 18]) {
+ now.mockReturnValue(at(m));
+ await keepSnapshot({ type: 'doc', v: m });
+ }
+ expect(snapshots()).toEqual([at(18), at(12), at(6)]);
+ expect(idb.data.size).toBe(3);
+ expect(await readSnapshot(at(12))).toEqual({ type: 'doc', v: 12 });
+ expect(await readSnapshot(at(0))).toBeNull();
+ });
+});