fix(editor): Task 1 review round 1, section back pops, scroll proof

This commit is contained in:
bchanot committed 2026-11-13 18:12:19 +01:00
1 parent 792394d3b2
commit 8e4f02620a
7 files changed
+251 -64

No files matched your search

+48 -3
View File
@@ -3,6 +3,7 @@ import type { Page, TestInfo } from '@playwright/test'
import { expect, test } from '../support/browser'
import { dropLateReplays, routeToSandbox } from '../support/sandbox'
import {
backToDrawing,
editorActor,
openEditor,
openSection,
@@ -26,8 +27,9 @@ const tabName = (tab: string) =>
new RegExp(`^${dict[`editor.tab.${tab}`]}( |$)`)
/**
* The history follows a move from an effect, a few milliseconds after the click: wait for
* the entry on top to name the tab before pressing Back (a user cannot be that quick).
* Waits until the entry on top of the history names `tab`. The adapter writes from an
* effect a few milliseconds after a click, so a script pressing Back at once would land
* on the wrong entry (a user cannot be that quick): every Back below waits through this.
*/
async function written(page: Page, tab: string) {
await page.waitForFunction(
@@ -88,7 +90,7 @@ test.describe('editor browser history', () => {
await expect(selected(page)).toHaveText(tabName('references'))
})
test('an Annotations section is an entry of its own: Back shows the drawing, Forward the section', async ({
test('an Annotations section is an entry: Back shows the drawing, Forward it', async ({
page,
}) => {
await open(page)
@@ -118,6 +120,49 @@ test.describe('editor browser history', () => {
await expect(selected(page)).toHaveText(tabName('annotations'))
})
test('« Retour au dessin » pops the section: Back leaves the drawing', async ({
page,
}) => {
await open(page)
await selectTab(page, dict, 'general')
await written(page, 'general')
await selectTab(page, dict, 'annotations')
await written(page, 'annotations')
await openSection(page, dict, 'views')
await sectionWritten(page, 'views')
await backToDrawing(page, dict)
await sectionWritten(page, 'drawing')
// no duplicate drawing entry: this Back lands on Général
await page.goBack()
await expect(selected(page)).toHaveText(tabName('general'))
})
test('the scroll offset of a view comes back with Back and Forward', async ({
page,
}) => {
await open(page)
await page.evaluate(() => {
const spacer = document.createElement('div')
spacer.style.height = '4000px'
document.body.append(spacer)
window.scrollTo(0, 600)
})
// The keyboard: a real click would scroll the tab row into view first, and a script
// event carries no user activation (Chromium skips such entries on Back).
await page
.getByRole('tab', { name: tabName('findings') })
.evaluate((tab) => tab.focus({ preventScroll: true }))
await page.keyboard.press('Enter')
await written(page, 'findings')
await page.evaluate(() => window.scrollTo(0, 200))
await page.goBack()
await expect(selected(page)).toHaveText(tabName('annotations'))
await page.waitForFunction(() => Math.abs(window.scrollY - 600) <= 2)
await page.goForward()
await expect(selected(page)).toHaveText(tabName('findings'))
await page.waitForFunction(() => Math.abs(window.scrollY - 200) <= 2)
})
test('a reload reopens the view of the entry', async ({ page }) => {
await open(page)
await selectTab(page, dict, 'findings')
+19 -4
View File
@@ -68,6 +68,8 @@ export function ownedEntry(
owner: HistoryOwner,
): HistoryEntry | null {
const entry = readEntry(state)
// An empty id is no owner: nobody signed in, no sheet known.
if (!owner.sheetId || !owner.userId) return null
const mine = entry?.sheetId === owner.sheetId && entry.userId === owner.userId
return mine ? entry : null
}
@@ -79,13 +81,26 @@ export function layerCount(view: EditorView): number {
return (view.finding ? 1 : 0) + (view.reference ? 1 : 0)
}
/** An Annotations section other than the drawing is a step over it, like a layer. */
function isStepOver(view: EditorView): boolean {
return view.tab === 'annotations' && view.section !== 'drawing'
}
/** True when the move took a layer away, or left a section for its drawing. */
function isRemoval(top: EditorView, view: EditorView): boolean {
if (layerCount(view) < layerCount(top)) return true
const backToDrawing = view.tab === top.tab && isStepOver(top)
return backToDrawing && !isStepOver(view) && layerCount(view) === 0
}
/** What a changed view asks of the history. */
export type HistoryWrite = 'none' | 'push' | 'replace' | 'back'
/**
* A user move to `view`. A layer taken away goes back when the entry holds the view the
* move lands on (the entry that opened the layer), else it replaces; a layer, tab or
* section added pushes, unless the move asked for a replace.
* A user move to `view`. A layer taken away, or a section left for its drawing ("Retour
* au dessin"), goes back when the entry holds the view the move lands on (the entry that
* opened it), else it replaces; a layer, tab or section added pushes, unless the move
* asked for a replace.
*/
export function planWrite(
top: HistoryEntry,
@@ -93,7 +108,7 @@ export function planWrite(
replace: boolean,
): HistoryWrite {
if (sameView(top.view, view)) return 'none'
if (layerCount(view) < layerCount(top.view)) {
if (isRemoval(top.view, view)) {
return top.below && sameView(top.below, view) ? 'back' : 'replace'
}
return replace ? 'replace' : 'push'
+80 -45
View File
@@ -34,7 +34,6 @@ interface Book {
backTimer: ReturnType<typeof setTimeout> | undefined
/** Scroll position of the entries left, by entry id. */
scrolls: Map<string, number>
lastScroll: number
counter: number
takeWrite: (now: number) => boolean
}
@@ -46,7 +45,6 @@ function newBook(): Book {
pendingBack: false,
backTimer: undefined,
scrolls: new Map(),
lastScroll: 0,
counter: 0,
takeWrite: createWriteBudget(WRITE_LIMIT, WRITE_WINDOW_MS),
}
@@ -84,6 +82,9 @@ function useWriter(book: Book, owner: HistoryOwner) {
}
const write = (entry: HistoryEntry, replace: boolean) => {
book.entry = entry
// shortcut: past the write budget a push is kept in memory only, so a later Back
// lands on the real previous entry. Fine at one push per user move; upgrade path:
// coalesce the skipped views into one replace once the window slides.
if (replace || book.takeWrite(Date.now())) send(entry, replace)
}
return {
@@ -155,22 +156,29 @@ function landOnForeign(ctx: PopContext): Landing | null {
return book.entry && { entry: book.entry, tabChanged: true }
}
/**
* Something the history does not carry is on screen: the view stays, the pre-POP view is
* pushed again above the entry landed on. A dirty form shows its own confirmation.
*/
function refusePop(ctx: PopContext, landed: HistoryEntry | null): null {
const { nav, book, writer, view } = ctx
nav.guards.askAll(false)
if (landed) book.entry = landed
writer.push(view)
return null
}
/** What the page does with the entry a Back or Forward landed on. */
function landOn(ctx: PopContext, state: unknown): Landing | null {
const { nav, book, writer, owner, view } = ctx
if (book.entry) book.scrolls.set(book.entry.id, book.lastScroll)
const { nav, book, owner, view } = ctx
// Scrolling is manual while the editor is mounted: the leaving page's offset is intact.
if (book.entry) book.scrolls.set(book.entry.id, window.scrollY)
const expected = book.pendingBack
book.pendingBack = false
clearTimeout(book.backTimer)
const entry = ownedEntry(state, owner)
if (!expected && popRefused(nav)) return refusePop(ctx, entry)
if (!entry) return landOnForeign(ctx)
if (!expected && popRefused(nav)) {
// The dirty form, if any, says so itself; the page keeps everything mounted.
nav.guards.askAll(false)
book.entry = entry
writer.push(view)
return null
}
book.entry = entry
if (sameView(entry.view, view)) return null
nav.restoreView(entry.view)
@@ -184,6 +192,13 @@ function mount(ctx: PopContext, state: unknown): void {
else ctx.writer.first(ctx.view)
}
/** Focus after a Back or Forward: the tab button, or the heading of a section reached. */
function landFocus({ entry, tabChanged }: Landing): void {
const heading = tabChanged ? null : headingOf(shownPlace(entry.view))
if (heading) heading.focus({ preventScroll: true })
else focusActiveTab({ preventScroll: true })
}
/** Scroll, focus and announcement once a Back or Forward has restored a view. */
function useLanding(
nav: EditorNavigation,
@@ -191,23 +206,64 @@ function useLanding(
landing: Landing | null,
) {
const moveText = useMoveText()
const { announce } = nav
const landed = useRef<Landing | null>(null)
useEffect(() => {
// A new wording (locale switch) re-creates `moveText`: the landing stays one.
if (!landing || landed.current === landing) return
landed.current = landing
const { entry, tabChanged } = landing
const { tab, section } = entry.view
const { id, view } = landing.entry
return afterModalsClosed(() => {
window.scrollTo(0, book.scrolls.get(entry.id) ?? 0)
const heading = tabChanged ? null : headingOf(shownPlace(entry.view))
if (heading) heading.focus({ preventScroll: true })
else focusActiveTab({ preventScroll: true })
const shown = tab === 'annotations' ? section : null
announce(moveText({ place: 'tab', tab, section: shown, key: null }))
window.scrollTo(0, book.scrolls.get(id) ?? 0)
landFocus(landing)
const section = view.tab === 'annotations' ? view.section : null
nav.announce(
moveText({ place: 'tab', tab: view.tab, section, key: null }),
)
})
}, [landing, book, announce, moveText])
}, [landing, book, nav, moveText])
}
/** The view the reducer holds, as one object that changes only when the view does. */
function useViewOf(state: EditorNavigation['state']): EditorView {
const { tab, section, finding, reference, referenceFilter } = state
return useMemo(
() => ({ tab, section, finding, reference, referenceFilter }),
[tab, section, finding, reference, referenceFilter],
)
}
/**
* The router's own restoration would scroll before the adapter has read the leaving
* page's offset: it is manual while the editor is mounted, the adapter restores itself.
*/
function useManualScroll(): void {
useEffect(() => {
const previous = window.history.scrollRestoration
window.history.scrollRestoration = 'manual'
return () => {
window.history.scrollRestoration = previous
}
}, [])
}
/** Each new location is read once: the first is the mount, a POP after it is a landing. */
function usePop(ctx: PopContext): Landing | null {
const location = useLocation()
const navType = useNavigationType()
const [landing, setLanding] = useState<Landing | null>(null)
const { book } = ctx
useEffect(() => {
// The type is part of the stamp: a POP back onto a key this adapter pushed, with the
// transition of a later push never rendered, is still a landing to read.
const stamp = `${location.key}|${navType}`
if (book.handled === stamp) return
book.handled = stamp
if (book.entry === null) mount(ctx, location.state)
else if (navType === 'POP') setLanding(landOn(ctx, location.state))
// Read once per location: the context is the one this render holds.
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [location.key, navType])
return landing
}
/**
@@ -224,33 +280,12 @@ export default function useEditorHistory(
owner: HistoryOwner,
defaultView: EditorView,
): void {
const location = useLocation()
const navType = useNavigationType()
const bookRef = useRef<Book | null>(null)
const book = (bookRef.current ??= newBook())
const writer = useWriter(book, owner)
const [landing, setLanding] = useState<Landing | null>(null)
const { tab, section, finding, reference, referenceFilter } = nav.state
const view = useMemo(
() => ({ tab, section, finding, reference, referenceFilter }),
[tab, section, finding, reference, referenceFilter],
)
const ctx = { nav, book, writer, owner, defaultView, view }
useEffect(() => {
if (book.handled === location.key) return
book.handled = location.key
if (book.entry === null) mount(ctx, location.state)
else if (navType === 'POP') setLanding(landOn(ctx, location.state))
// Read once per location: the context is the one this render holds.
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [location.key])
const view = useViewOf(nav.state)
const landing = usePop({ nav, book, writer, owner, defaultView, view })
useReconcile(nav, view, book, writer)
useLanding(nav, book, landing)
useEffect(() => {
const onScroll = () => {
book.lastScroll = window.scrollY
}
window.addEventListener('scroll', onScroll, { passive: true })
return () => window.removeEventListener('scroll', onScroll)
}, [book])
useManualScroll()
}
+4 -2
View File
@@ -163,10 +163,12 @@ export function useMoveText(): (target: EditorTarget) => string {
function useLiveRegion() {
const [live, setLive] = useState('')
const queued = useRef<string[]>([])
const waiting = useRef<() => void>(() => undefined)
const announce = useCallback((text: string) => {
queued.current.push(text)
if (queued.current.length > 1) return
afterModalsClosed(() => {
// Each message re-arms the wait, so a wait that never fires cannot hold later ones.
waiting.current()
waiting.current = afterModalsClosed(() => {
const joined = queued.current.splice(0).join('. ')
setLive((previous) => (previous === joined ? `${joined} ` : joined))
})
@@ -68,6 +68,14 @@ describe('readEntry and ownership', () => {
expect(ownedEntry(stateOf(entry()), { ...mine, userId: 'V' })).toBeNull()
})
it('refuses an owner without a sheet or an account', () => {
const blank = entry({ sheetId: '', userId: '' })
expect(ownedEntry(stateOf(blank), { sheetId: '', userId: '' })).toBeNull()
expect(
ownedEntry(stateOf(entry()), { sheetId: 'S', userId: '' }),
).toBeNull()
})
it('keeps only navigation: nothing typed survives the read', () => {
const raw = { ...entry(), draft: 'typed text', term: 'search' }
expect(JSON.stringify(readEntry(stateOf(raw)))).not.toContain('typed')
@@ -92,6 +100,21 @@ describe('planWrite', () => {
expect(planWrite(onAnnotations, views, false)).toBe('push')
})
it('goes back for a section left for its drawing, else replaces', () => {
const drawing = view('annotations')
const inSection = entry({
view: view('annotations', { section: 'views' }),
below: drawing,
})
expect(planWrite(inSection, drawing, false)).toBe('back')
const reloaded = entry({ view: inSection.view, below: null })
expect(planWrite(reloaded, drawing, false)).toBe('replace')
// another section, or another tab, is a step forward
const regions = view('annotations', { section: 'regions' })
expect(planWrite(inSection, regions, false)).toBe('push')
expect(planWrite(inSection, view('general'), false)).toBe('push')
})
it('goes back for a layer removed when the entry holds the view below', () => {
const layer = view('findings', { reference: { create: true } })
const opened = entry({ view: layer, below: view('findings') })
@@ -128,6 +128,21 @@ describe('the announcer', () => {
})
})
describe('the announcer, a wait that never fires', () => {
it('does not hold later messages back', async () => {
const user = userEvent.setup()
mount()
const dialog = document.createElement('dialog')
dialog.setAttribute('open', '')
document.body.append(dialog)
await user.click(screen.getByRole('button', { name: 'say one' }))
// the dialog goes without ModalDialog's cleanup: nothing flushes the queue
dialog.remove()
await user.click(screen.getByRole('button', { name: 'say two' }))
expect(screen.getByTestId('live')).toHaveTextContent('one. two')
})
})
describe('useBeforeUnload', () => {
it('asks while dirty and stops when clean', () => {
const { rerender } = renderHook(({ dirty }) => useBeforeUnload(dirty), {
+62 -10
View File
@@ -99,7 +99,7 @@ describe('mount', () => {
})
describe('tab and section moves', () => {
it('a tab click pushes, Back and Forward restore it, the tab button holds the focus', async () => {
it('a tab click pushes, Back and Forward restore it, the tab holds focus', async () => {
const user = userEvent.setup()
mountDraft({ probe })
await ready()
@@ -132,22 +132,24 @@ describe('tab and section moves', () => {
expect(selected()).not.toBe('Constats')
})
it('an Annotations section pushes, « Retour au dessin » too, Back returns to the section', async () => {
// R-24: the first version of this case expected « Retour au dessin » to push and Back to
// return to the section; R2F-1 makes it a removal (a pop), so no duplicate entry remains.
it('a section is an entry; « Retour au dessin » pops it: no duplicate', async () => {
const user = userEvent.setup()
mountDraft({ probe })
mountDraft({ probe, entries: ['/app/admin', path] })
await ready()
await user.click(tab('Annotations'))
await waitFor(() => expect(written()?.view.tab).toBe('annotations'))
const drawing = written()?.id
await user.click(screen.getByRole('button', { name: 'Vues' }))
await waitFor(() => expect(written()?.view.section).toBe('views'))
expect(written()?.below?.section).toBe('drawing')
await user.click(screen.getByRole('button', { name: 'Retour au dessin' }))
await waitFor(() => expect(written()?.view.section).toBe('drawing'))
await waitFor(() => expect(written()?.id).toBe(drawing))
expect(written()?.view.section).toBe('drawing')
// one more Back leaves the drawing for the entry before it, not for the section
back()
await waitFor(() =>
expect(
screen.getByRole('button', { name: 'Retour au dessin' }),
).toBeVisible(),
)
expect(written()?.view.section).toBe('views')
await waitFor(() => expect(selected()).not.toBe('Annotations'))
})
it('a move that changes nothing writes nothing', async () => {
@@ -161,7 +163,57 @@ describe('tab and section moves', () => {
})
})
describe('scroll', () => {
const scrollAt = (y: number) =>
Object.defineProperty(window, 'scrollY', { configurable: true, value: y })
afterEach(() => scrollAt(0))
it('takes the offset in the move, restores it on Back', async () => {
const scrollTo = vi.spyOn(window, 'scrollTo').mockImplementation(() => {})
const user = userEvent.setup()
mountDraft({ probe })
await ready()
await waitFor(() => expect(written()).toBeTruthy())
scrollAt(300)
await user.click(tab('Constats'))
await waitFor(() => expect(written()?.view.tab).toBe('findings'))
scrollAt(40)
back()
await waitFor(() => expect(scrollTo).toHaveBeenCalledWith(0, 300))
back(1)
await waitFor(() => expect(scrollTo).toHaveBeenCalledWith(0, 40))
})
it('is manual while the editor is mounted, as it was after', async () => {
window.history.scrollRestoration = 'auto'
const view = mountDraft({ probe })
await ready()
expect(window.history.scrollRestoration).toBe('manual')
view.unmount()
expect(window.history.scrollRestoration).toBe('auto')
})
})
describe('a Back that must not unmount what is on screen', () => {
it('also refuses to replace a foreign entry while a dialog is open', async () => {
const entries = [{ pathname: path, state: foreign({ sheetId: 'x' }) }, path]
mountDraft({ probe, entries })
await ready()
await waitFor(() => expect(written()?.sheetId).toBe(SHEET))
const before = selected()
const dialog = document.createElement('dialog')
dialog.setAttribute('open', '')
document.body.append(dialog)
const id = written()?.id
back()
await waitFor(() => expect(written()?.id).not.toBe(id))
expect(selected()).toBe(before)
expect(written()?.sheetId).toBe(SHEET)
// pushed again above the landed entry, not replaced by a first entry
expect(written()?.below).not.toBeNull()
dialog.remove()
})
it('keeps the view and pushes it again while a dialog is open', async () => {
const user = userEvent.setup()
mountDraft({ probe })