diff --git a/apps/app/src/editor/state/editorLoad.ts b/apps/app/src/editor/state/editorLoad.ts index 95e04971..036d4355 100644 --- a/apps/app/src/editor/state/editorLoad.ts +++ b/apps/app/src/editor/state/editorLoad.ts @@ -210,6 +210,7 @@ export async function discardChanges( const state = api.get() const block = blockKind(state) if (block || !state.preview) return { ok: false, reason: 'blocked', kind: block ?? 'not_ready' } + if (state.saving || state.submitting) return { ok: false, reason: 'blocked', kind: 'busy' } if (!option.confirmed) return { ok: false, reason: 'blocked', kind: 'confirmation_required' } if (state.staleBase) return reloadServerDraft(api, option) const replaced = state.preview.replaceDocument(state.savedText) diff --git a/apps/app/src/editor/state/editorSave.ts b/apps/app/src/editor/state/editorSave.ts index aae6af65..70d16427 100644 --- a/apps/app/src/editor/state/editorSave.ts +++ b/apps/app/src/editor/state/editorSave.ts @@ -55,7 +55,8 @@ function conflictFrom(admin: OfficialSheetAdmin, state: EditorState): ConflictSt /** Reads the conflict; a failed read or an unparsable answer is the `unknown` variant. */ export async function readConflict(api: StoreApi, session: number): Promise { const state = api.get() - api.set({ conflict: { status: 'reading' } }) + const reading: ConflictState = { status: 'reading' } + api.set({ conflict: reading }) let next: ConflictState try { const admin = await getOfficialSheetAdmin(requireClient(), state.sheetId ?? '') @@ -63,7 +64,10 @@ export async function readConflict(api: StoreApi, session: number): Promise()((set, get) => { ...initialData(), open: (versionId, userId, options) => open(api, versionId, userId, options), close: () => close(api), - setCanEdit: (canEdit) => set({ canEdit }), + setCanEdit: (canEdit) => setCanEdit(api, canEdit), commit: (command, options) => commit(api, command, options?.accept), undoStep: () => stepHistory(api, 'undo'), redoStep: () => stepHistory(api, 'redo'), diff --git a/apps/app/src/editor/state/editorTypes.ts b/apps/app/src/editor/state/editorTypes.ts index aacbd811..461d3a2a 100644 --- a/apps/app/src/editor/state/editorTypes.ts +++ b/apps/app/src/editor/state/editorTypes.ts @@ -19,6 +19,7 @@ export type BlockKind = | 'confirmation_required' | 'stale_base' | 'revision_unknown' + | 'unsaved' | 'session_changed' export interface Blocked { diff --git a/apps/app/src/editor/state/recoveryFlow.ts b/apps/app/src/editor/state/recoveryFlow.ts index 6c9eb91a..570d095a 100644 --- a/apps/app/src/editor/state/recoveryFlow.ts +++ b/apps/app/src/editor/state/recoveryFlow.ts @@ -68,6 +68,32 @@ export function detectRecovery(input: DetectInput): RecoveryPatch { return { ...NO_RECOVERY, recovery: 'pending', offer } } +/** + * A mode change. Becoming editable re-runs the recovery detection (a copy found while the + * mode could not use it is offered or refused now, never overwritten); unsaved work of + * this session is kept as is. + */ +export function setCanEdit(api: StoreApi, canEdit: boolean): void { + const state = api.get() + if (canEdit === state.canEdit) return + const ready = state.status === 'ready' && state.userId !== null + if (!canEdit || !ready || state.unsaved) { + const unusable = ready && !canEdit && copyExists(state.userId ?? '', state.versionId ?? '') + api.set({ canEdit, unusableCopy: unusable }) + return + } + api.set({ + canEdit, + ...detectRecovery({ + userId: state.userId ?? '', + versionId: state.versionId ?? '', + canEdit, + savedText: state.savedText, + savedRevision: state.savedRevision, + }), + }) +} + function sheetNameOf(state: EditorState): string { const name = state.previewState?.document.name return name?.fr.trim() || name?.en.trim() || state.versionId || '' @@ -94,7 +120,7 @@ function buildCopy(state: EditorState): RecoveryCopy { */ export function syncCopy(api: StoreApi): void { const state = api.get() - const live = state.status === 'ready' && state.canEdit + const live = state.status === 'ready' && state.canEdit && !state.unusableCopy if (!live || state.recovery !== 'none' || !state.unsaved) return const result = writeCopy(buildCopy(state)) api.set({ diff --git a/apps/app/tests/unit/editor-recovery.test.ts b/apps/app/tests/unit/editor-recovery.test.ts index dd417da1..70684a99 100644 --- a/apps/app/tests/unit/editor-recovery.test.ts +++ b/apps/app/tests/unit/editor-recovery.test.ts @@ -263,3 +263,35 @@ describe('cap, quota and other accounts', () => { expect(storedCopy()).toBeNull() }) }) + +describe('becoming editable with a stored copy', () => { + it('offers a different copy and keeps its bytes, commit refused', async () => { + seed(movedText(10), 3) + const raw = sessionStorage.getItem(copyKeyOf()) + await openReady({ canEdit: false }) + store.getState().setCanEdit(true) + expect(store.getState()).toMatchObject({ recovery: 'pending', unusableCopy: false }) + expect(commitMove(40)).toMatchObject({ kind: 'recovery.pending' }) + expect(sessionStorage.getItem(copyKeyOf())).toBe(raw) + }) + + it('refuses an unreadable copy and never overwrites it', async () => { + sessionStorage.setItem(copyKeyOf(), 'not json{') + await openReady({ canEdit: false }) + store.getState().setCanEdit(true) + expect(store.getState()).toMatchObject({ recovery: 'refused', refusedKind: 'unreadable' }) + expect(commitMove(40)).toMatchObject({ kind: 'recovery.pending' }) + expect(sessionStorage.getItem(copyKeyOf())).toBe('not json{') + }) + + it('does not write over a copy flagged unusable', async () => { + seed(movedText(10), 3) + const raw = sessionStorage.getItem(copyKeyOf()) + await openReady() + store.getState().ignoreCopy({ confirmed: true }) + seed(movedText(10), 3) + store.setState({ unusableCopy: true }) + commitMove(40) + expect(sessionStorage.getItem(copyKeyOf())).toBe(raw) + }) +}) diff --git a/apps/app/tests/unit/editor-store.test.ts b/apps/app/tests/unit/editor-store.test.ts index df81f16e..74f3563c 100644 --- a/apps/app/tests/unit/editor-store.test.ts +++ b/apps/app/tests/unit/editor-store.test.ts @@ -332,3 +332,35 @@ describe('discard and submit', () => { expect(store.getState().conflict).toEqual({ status: 'unknown' }) }) }) + +describe('guards', () => { + it('refuses a submit while the document differs from the saved text', async () => { + await openReady() + commitMove(40) + expect(await store.getState().submit()).toMatchObject({ ok: false, kind: 'unsaved' }) + expect(sb.submitSheetReview).not.toHaveBeenCalled() + }) + + it('refuses a discard while a save is in flight', async () => { + await openReady() + commitMove(40) + sb.saveSheetDraft.mockReturnValue(deferred().promise as never) + void store.getState().save() + expect(await store.getState().discardChanges({ confirmed: true })).toMatchObject({ kind: 'busy' }) + expect(store.getState().unsaved).toBe(true) + }) + + it('drops a conflict read that lands after dismissal', async () => { + await openReady() + commitMove(40) + const late = deferred() + sb.saveSheetDraft.mockRejectedValue(new SheetFailure('draft_conflict')) + sb.getOfficialSheetAdmin.mockReturnValue(late.promise as never) + const saving = store.getState().save() + await vi.waitFor(() => expect(store.getState().conflict).toEqual({ status: 'reading' })) + store.getState().dismissConflict() + late.resolve({ draft_version: { version_id: VERSION, version_number: 1, revision: 5 }, draft_last_save: null }) + await saving + expect(store.getState().conflict).toBeNull() + }) +})