feat(editor): browser history for tabs, sections and Aller a

EditorView held by the navigation reducer (restore_view), a history
adapter hook mounted in EditorWorkspace (push, replace, back, mount
rule, ownership, write budget, scroll map, refused POP), a guard stack
by layer, an announcer queue joined after open dialogs.
This commit is contained in:
bchanot committed 2026-11-13 17:57:52 +01:00
1 parent 69e225ca7a
commit 792394d3b2
11 files changed
+1268 -40

No files matched your search

+155
View File
@@ -0,0 +1,155 @@
import { fr } from '@/i18n/fr'
import type { Page, TestInfo } from '@playwright/test'
import { expect, test } from '../support/browser'
import { dropLateReplays, routeToSandbox } from '../support/sandbox'
import {
editorActor,
openEditor,
openSection,
place,
pointOf,
seedDraft,
selectTab,
shapeWith,
} from '../support/editor'
// R2 UX finish, task 1 (R2F-1): the browser's Back and Forward walk the editor's tabs and
// Annotations sections. Chromium's own history (page.goBack) drives them; the top-layer and
// focus rules are the browser's, so they are proved here and not in happy-dom.
const dict = fr
const isPhone = (info: TestInfo) => info.project.name === 'chromium-375'
const dialog = (page: Page) => page.getByRole('dialog')
const selected = (page: Page) => page.getByRole('tab', { selected: true })
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).
*/
async function written(page: Page, tab: string) {
await page.waitForFunction(
(wanted) => history.state?.usr?.editorEntry?.view?.tab === wanted,
tab,
)
}
async function sectionWritten(page: Page, section: string) {
await page.waitForFunction(
(wanted) => history.state?.usr?.editorEntry?.view?.section === wanted,
section,
)
}
async function open(page: Page) {
const actor = await editorActor('fr')
const linked = pointOf('p1', 'main', { cx: 500, cy: 400, r: 40 }, 'Point lié')
const seed = await seedDraft(actor, { shape: shapeWith(linked) })
await openEditor(page, dict, actor, seed.sheetId)
await expect(selected(page)).toHaveText(tabName('annotations'))
return seed
}
test.describe('editor browser history', () => {
test.use({ locale: 'fr-FR', actionTimeout: 15_000 })
test.beforeEach(async ({ context }, info) => {
test.skip(isPhone(info), 'editing needs 1 024 px') // floor-guard: allow C16 editing needs >= 1024 px; phone read-only covered in editor-access
await routeToSandbox(context)
})
test.afterEach(async ({ context }) => {
await dropLateReplays(context)
})
test('tabs: Back and Forward restore them, the tab button holds the focus', async ({
page,
}) => {
await open(page)
await selectTab(page, dict, 'findings')
await written(page, 'findings')
await selectTab(page, dict, 'references')
await written(page, 'references')
await page.goBack()
await expect(selected(page)).toHaveText(tabName('findings'))
await expect(page.locator(':focus')).toHaveAttribute(
'id',
'editor-tab-findings',
)
await page.goBack()
await expect(selected(page)).toHaveText(tabName('annotations'))
await expect(page.locator(':focus')).toHaveAttribute(
'id',
'editor-tab-annotations',
)
await page.goForward()
await expect(selected(page)).toHaveText(tabName('findings'))
await page.goForward()
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 ({
page,
}) => {
await open(page)
await openSection(page, dict, 'categories')
await sectionWritten(page, 'categories')
await page.goBack()
await expect(place(page, 'annotations.drawing')).toBeVisible()
await expect(place(page, 'annotations.categories')).toBeHidden()
await expect(page.locator(':focus')).not.toHaveJSProperty('tagName', 'BODY')
await page.goForward()
await expect(place(page, 'annotations.categories')).toBeVisible()
})
test('arrow keys along the tab row replace the entry: one Back leaves the walk', async ({
page,
}) => {
await open(page)
await selectTab(page, dict, 'findings')
await written(page, 'findings')
await page.keyboard.press('ArrowRight')
await expect(selected(page)).toHaveText(tabName('references'))
await written(page, 'references')
await page.keyboard.press('ArrowRight')
await expect(selected(page)).toHaveText(tabName('verification'))
await written(page, 'verification')
await page.goBack()
await expect(selected(page)).toHaveText(tabName('annotations'))
})
test('a reload reopens the view of the entry', async ({ page }) => {
await open(page)
await selectTab(page, dict, 'findings')
await written(page, 'findings')
await page.reload()
await expect(selected(page)).toHaveText(tabName('findings'))
await page.goBack()
await expect(selected(page)).toHaveText(tabName('annotations'))
})
test('a DeleteDialog open when Back is pressed stays open, the view unchanged', async ({
page,
}) => {
await open(page)
await openSection(page, dict, 'categories')
await sectionWritten(page, 'categories')
await page
.getByRole('listitem')
.filter({ has: page.locator('#category-cat-a-name-fr') })
.getByRole('button', { name: dict['editor.action.delete'] })
.click()
await expect(dialog(page)).toBeVisible()
await page.goBack()
await expect(dialog(page)).toBeVisible()
await expect(place(page, 'annotations.categories')).toBeVisible()
await dialog(page)
.getByRole('button', { name: dict['editor.delete.close'], exact: true })
.last()
.click()
await expect(dialog(page)).toHaveCount(0)
// The refused Back left the section one entry above the drawing: this one goes.
await page.goBack()
await expect(place(page, 'annotations.drawing')).toBeVisible()
})
})
@@ -41,7 +41,10 @@ function ErrorCount({ tab }: { tab: EditorTabId }) {
}
/** Answers false when the change was refused (a field of the open panel refused to apply). */
type SelectTab = (tab: EditorTabId) => boolean | void
type SelectTab = (
tab: EditorTabId,
options?: { replace?: boolean },
) => boolean | void
interface TabListProps {
shown: readonly EditorTabId[]
@@ -59,7 +62,8 @@ function TabList({ shown, active, onSelect }: TabListProps) {
if (step === 0 || at < 0) return
event.preventDefault()
const next = shown[(at + step + shown.length) % shown.length]
if (onSelect(next) === false) return
// An arrow-key walk along the row replaces its history entry instead of adding one.
if (onSelect(next, { replace: true }) === false) return
document.getElementById(tabDomId(next))?.focus()
}
return (
@@ -1,4 +1,5 @@
import { useEffect, useRef, type ReactNode } from 'react'
import { useEffect, useMemo, useRef, useState, type ReactNode } from 'react'
import { useLocation } from 'react-router-dom'
import { AnimatePresence } from 'motion/react'
import type { ElementKey } from '@faunosteo/core-wasm/types'
import type { OfficialSheetAdmin } from '@faunosteo/supabase'
@@ -12,6 +13,9 @@ import {
import { saveFailureMessage } from '@/editor/messages'
import type { EditorMode } from '@/editor/mode'
import { useEditorStore } from '@/editor/state/editorStore'
import { ownedEntry } from '@/editor/history/entry'
import useEditorHistory from '@/editor/history/useEditorHistory'
import { defaultView } from '@/editor/navigation'
import { initialTab } from '@/editor/tabs'
import {
useEditorNavigation,
@@ -19,6 +23,7 @@ import {
} from '@/editor/useEditorNavigation'
import type { TabTier } from '@/editor/useViewport'
import { useT } from '@/i18n/useT'
import { useAuthStore } from '@/state/authStore'
import ConflictDialog from './ConflictDialog'
import CopyIssueNotice from './CopyIssueNotice'
import DraftHeader from './DraftHeader'
@@ -156,9 +161,17 @@ function useBodyEscape(open: boolean, close: () => void) {
export default function EditorWorkspace(props: Props) {
const { sheet, mode, readOnly, tier, reloadSheet } = props
const previewState = useEditorStore((s) => s.previewState)
const nav = useEditorNavigation(
previewState ? initialTab(previewState, tier) : 'annotations',
const tab = previewState ? initialTab(previewState, tier) : 'annotations'
const userId = useAuthStore((s) => s.user?.id ?? '')
const owner = useMemo(
() => ({ sheetId: sheet.sheet_id, userId }),
[sheet.sheet_id, userId],
)
// A reload or a reopened entry shows the view the history kept, never a layer.
const { state } = useLocation()
const [entry] = useState(() => ownedEntry(state, owner))
const nav = useEditorNavigation(tab, entry?.view)
useEditorHistory(nav, owner, defaultView(tab))
const open = nav.state.citationsOf !== null
useBodyEscape(open, nav.closeCitations)
return (
+111
View File
@@ -0,0 +1,111 @@
import {
ANNOTATION_SECTIONS,
sameView,
type AnnotationSection,
type EditorView,
} from '../navigation'
import { EDITOR_TABS, type EditorTabId } from '../tabs'
/**
* What one browser history entry of the editor holds (R2F-1): the view, the view below
* it (the place a Back returns to), and whose editor wrote it. Navigation only: never
* typed text, a search term or a draft.
*/
export interface HistoryEntry {
/** Keys the scroll map: one per entry written, kept by a replace. */
id: string
view: EditorView
below: EditorView | null
sheetId: string
userId: string
}
/** The sheet and the account an entry may be restored for. */
export interface HistoryOwner {
sheetId: string
userId: string
}
/** The key of the entry inside the router's `location.state`. */
export const ENTRY_KEY = 'editorEntry'
const isRecord = (value: unknown): value is Record<string, unknown> =>
typeof value === 'object' && value !== null
/**
* A view read back from a history entry, or null when it is no view. Vanished keys drop
* their layer: no layer is ever written yet, so the three layer fields come back null.
* shortcut: later layers validate their key against the loaded sheet here.
*/
export function sanitizeView(raw: unknown): EditorView | null {
if (!isRecord(raw)) return null
if (!EDITOR_TABS.includes(raw.tab as EditorTabId)) return null
const known = ANNOTATION_SECTIONS.includes(raw.section as AnnotationSection)
return {
tab: raw.tab as EditorTabId,
section: known ? (raw.section as AnnotationSection) : 'drawing',
finding: null,
reference: null,
referenceFilter: null,
}
}
/** The entry `state` (a `location.state`) carries, or null when it carries none. */
export function readEntry(state: unknown): HistoryEntry | null {
const raw = isRecord(state) ? state[ENTRY_KEY] : null
if (!isRecord(raw)) return null
const view = sanitizeView(raw.view)
const { id, sheetId, userId } = raw
if (!view || typeof id !== 'string') return null
if (typeof sheetId !== 'string' || typeof userId !== 'string') return null
const below = raw.below === null ? null : sanitizeView(raw.below)
return { id, view, below, sheetId, userId }
}
/** An entry restores only for the sheet and the account that wrote it. */
export function ownedEntry(
state: unknown,
owner: HistoryOwner,
): HistoryEntry | null {
const entry = readEntry(state)
const mine = entry?.sheetId === owner.sheetId && entry.userId === owner.userId
return mine ? entry : null
}
export const entryState = (entry: HistoryEntry) => ({ [ENTRY_KEY]: entry })
/** Layers over the place: a finding dialog or a reference dialog each count one. */
export function layerCount(view: EditorView): number {
return (view.finding ? 1 : 0) + (view.reference ? 1 : 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.
*/
export function planWrite(
top: HistoryEntry,
view: EditorView,
replace: boolean,
): HistoryWrite {
if (sameView(top.view, view)) return 'none'
if (layerCount(view) < layerCount(top.view)) {
return top.below && sameView(top.below, view) ? 'back' : 'replace'
}
return replace ? 'replace' : 'push'
}
/** Sliding-window budget of history writes: past it a view stays in memory. */
export function createWriteBudget(limit: number, windowMs: number) {
const stamps: number[] = []
return (now: number): boolean => {
while (stamps.length > 0 && now - stamps[0] >= windowMs) stamps.shift()
if (stamps.length >= limit) return false
stamps.push(now)
return true
}
}
@@ -0,0 +1,256 @@
import { useEffect, useMemo, useRef, useState } from 'react'
import { useLocation, useNavigate, useNavigationType } from 'react-router-dom'
import { afterModalsClosed } from '@/components/ui/afterModalsClosed'
import { focusActiveTab } from '../focusRequest'
import { sameView, type EditorView } from '../navigation'
import {
headingOf,
shownPlace,
useMoveText,
type EditorNavigation,
} from '../useEditorNavigation'
import {
createWriteBudget,
entryState,
ownedEntry,
planWrite,
type HistoryEntry,
type HistoryOwner,
} from './entry'
/** Well under WebKit's 100 history writes per 10 s: past it a view stays in memory. */
const WRITE_LIMIT = 40
const WRITE_WINDOW_MS = 10_000
/** A `back()` that never lands (nothing to go back to) stops blocking writes after this. */
const BACK_TIMEOUT_MS = 1_000
/** What the adapter keeps between renders; none of it is rendered. */
interface Book {
/** The entry on top of the history as the adapter knows it (null before the mount). */
entry: HistoryEntry | null
/** The router key last looked at, so each location is read once. */
handled: string | null
pendingBack: boolean
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
}
function newBook(): Book {
return {
entry: null,
handled: null,
pendingBack: false,
backTimer: undefined,
scrolls: new Map(),
lastScroll: 0,
counter: 0,
takeWrite: createWriteBudget(WRITE_LIMIT, WRITE_WINDOW_MS),
}
}
/** A Back or Forward that changed the view: what the landing scrolls to, focuses and says. */
interface Landing {
entry: HistoryEntry
tabChanged: boolean
}
/**
* The writes, through the router so its own location follows. `push` over the write
* budget keeps the entry in memory only; `replace` swallows a refused write.
*/
function useWriter(book: Book, owner: HistoryOwner) {
const navigate = useNavigate()
const location = useLocation()
const latest = useRef({ navigate, location })
latest.current = { navigate, location }
return useMemo(() => {
const send = (entry: HistoryEntry, replace: boolean) => {
const { navigate, location } = latest.current
const { pathname, search, hash } = location
const to = { pathname, search, hash }
try {
navigate(to, { replace, state: entryState(entry) })
} catch {
// The view stays in memory; the next move writes again.
}
}
const fresh = (view: EditorView, below: EditorView | null) => {
book.counter += 1
return { id: `e${book.counter}`, view, below, ...owner }
}
const write = (entry: HistoryEntry, replace: boolean) => {
book.entry = entry
if (replace || book.takeWrite(Date.now())) send(entry, replace)
}
return {
push: (view: EditorView) =>
write(fresh(view, book.entry?.view ?? null), false),
replace: (view: EditorView) => {
const kept = book.entry ?? fresh(view, null)
write({ ...kept, view }, true)
},
first: (view: EditorView) => write(fresh(view, null), true),
back: () => {
book.pendingBack = true
clearTimeout(book.backTimer)
book.backTimer = setTimeout(() => {
book.pendingBack = false
}, BACK_TIMEOUT_MS)
latest.current.navigate(-1)
},
}
}, [book, owner])
}
type Writer = ReturnType<typeof useWriter>
/** User moves: the view changed, the history follows (R2F-1). */
function useReconcile(
nav: EditorNavigation,
view: EditorView,
book: Book,
writer: Writer,
) {
useEffect(() => {
const { scrollY, replace } = nav.trace
nav.trace.scrollY = null
nav.trace.replace = false
const top = book.entry
if (!top || book.pendingBack) return
const plan = planWrite(top, view, replace)
if (plan === 'none') return
book.scrolls.set(top.id, scrollY ?? window.scrollY)
if (plan === 'back') writer.back()
else if (plan === 'push') writer.push(view)
else writer.replace(view)
}, [view, nav.trace, book, writer])
}
/** The page shows something the history does not carry: a POP must not unmount it. */
function popRefused(nav: EditorNavigation): boolean {
return (
document.querySelector('dialog[open]') !== null ||
nav.state.citationsOf !== null
)
}
interface PopContext {
nav: EditorNavigation
book: Book
writer: Writer
owner: HistoryOwner
defaultView: EditorView
view: EditorView
}
/** The entry of a Back or Forward is not this editor's: the default view replaces it. */
function landOnForeign(ctx: PopContext): Landing | null {
const { nav, writer, defaultView, book } = ctx
writer.first(defaultView)
nav.restoreView(defaultView)
return book.entry && { entry: book.entry, tabChanged: true }
}
/** 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 expected = book.pendingBack
book.pendingBack = false
clearTimeout(book.backTimer)
const entry = ownedEntry(state, owner)
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)
return { entry, tabChanged: entry.view.tab !== view.tab }
}
/** The first location of the editor: an entry of this sheet and account is kept, else replaced. */
function mount(ctx: PopContext, state: unknown): void {
const entry = ownedEntry(state, ctx.owner)
if (entry) ctx.book.entry = entry
else ctx.writer.first(ctx.view)
}
/** Scroll, focus and announcement once a Back or Forward has restored a view. */
function useLanding(
nav: EditorNavigation,
book: Book,
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
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 }))
})
}, [landing, book, announce, moveText])
}
/**
* The browser's history of the editor (R2F-1), kept in step with the view the navigation
* reducer holds. A move dispatches at once and the history follows from one effect that
* compares the view with the last entry this adapter wrote (a ref, never `useLocation()`,
* which lags a transition). A Back or Forward restores the view of the entry it lands on,
* unless a dialog or the citations panel is open: then the pre-move view is pushed back.
* Foreign entries (another sheet, another account) and entries without a view are replaced
* by the default view.
*/
export default function useEditorHistory(
nav: EditorNavigation,
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])
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])
}
+80 -5
View File
@@ -26,9 +26,24 @@ export interface FocusRequest {
serial: number
}
export interface NavigationState {
/**
* What the browser history records of the editor (R2F-1): where the user is, never what
* they typed. A layer (`finding`, `reference`) is a dialog over a place; `referenceFilter`
* narrows the references library to the citers of an element. Only `tab` and `section`
* are ever set so far: the three others are the room later layers fill.
*/
export interface EditorView {
tab: EditorTabId
section: AnnotationSection
finding:
| { key: ElementKey; citations: boolean }
| { create: { kind: string; parent: ElementKey | null } }
| null
reference: { edit: string } | { create: true } | null
referenceFilter: ElementKey | null
}
export interface NavigationState extends EditorView {
/** The finding whose citations panel is open; null while it is closed. */
citationsOf: ElementKey | null
/** Bumped by `show_all_references`: the library resets its search once per bump. */
@@ -49,6 +64,7 @@ export type NavigationAction =
| { type: 'close_citations' }
| { type: 'show_all_references' }
| { type: 'go_to'; target: EditorTarget }
| { type: 'restore_view'; view: EditorView }
| { type: 'focus_consumed'; serial: number }
const TAB_OF_KIND = {
@@ -97,11 +113,33 @@ function shown(state: NavigationState): NavigationState {
return { ...state, visitedTabs, visitedSections }
}
export function initialNavigation(tab: EditorTabId): NavigationState {
const DEFAULT_VIEW = {
section: 'drawing',
finding: null,
reference: null,
referenceFilter: null,
} as const
/** The finding whose citations panel the view shows, null when it shows none. */
function citationsOfView(view: EditorView): ElementKey | null {
const { finding } = view
return finding && 'key' in finding && finding.citations ? finding.key : null
}
/** The view a fresh editor shows on `tab`: the drawing, no layer. */
export function defaultView(tab: EditorTabId): EditorView {
return { ...DEFAULT_VIEW, tab }
}
/** `view` (a history entry read at mount) or the plain default view of `tab`. */
export function initialNavigation(
tab: EditorTabId,
view?: EditorView | null,
): NavigationState {
const start = view ?? defaultView(tab)
return shown({
tab,
section: 'drawing',
citationsOf: null,
...start,
citationsOf: citationsOfView(start),
libraryReset: 0,
visitedTabs: [],
visitedSections: [],
@@ -110,6 +148,41 @@ export function initialNavigation(tab: EditorTabId): NavigationState {
})
}
/** The part of the state the browser history records. */
export function viewOf(state: NavigationState): EditorView {
const { tab, section, finding, reference, referenceFilter } = state
return { tab, section, finding, reference, referenceFilter }
}
/**
* The same place for the history: a section only counts on Annotations (the other tabs
* keep the last one in memory, nobody sees it).
*/
export function sameView(a: EditorView, b: EditorView): boolean {
const section = a.tab !== 'annotations' || a.section === b.section
return (
a.tab === b.tab &&
section &&
JSON.stringify([a.finding, a.reference, a.referenceFilter]) ===
JSON.stringify([b.finding, b.reference, b.referenceFilter])
)
}
/** A Back or Forward landed on `view`: the page shows it, no request to answer. */
function restoreView(
state: NavigationState,
view: EditorView,
): NavigationState {
const section = view.tab === 'annotations' ? view.section : state.section
return shown({
...state,
...view,
section,
citationsOf: citationsOfView(view),
focus: undefined,
})
}
/**
* A finding node (kind `finding` below its family, path of two or more ids). A zone and a
* family list their citations inline and have no panel.
@@ -166,6 +239,8 @@ export function navigationReducer(
return showAllReferences(state)
case 'go_to':
return goTo(state, action.target)
case 'restore_view':
return restoreView(state, action.view)
case 'focus_consumed':
return state.focus?.serial === action.serial
? { ...state, focus: undefined }
+128 -28
View File
@@ -1,6 +1,7 @@
import {
useCallback,
useEffect,
useMemo,
useReducer,
useRef,
useState,
@@ -8,6 +9,7 @@ import {
type RefObject,
} from 'react'
import type { ElementKey } from '@faunosteo/core-wasm/types'
import { afterModalsClosed } from '@/components/ui/afterModalsClosed'
import { useT } from '@/i18n/useT'
import {
commitFocusedField,
@@ -23,6 +25,7 @@ import {
navigationReducer,
type AnnotationSection,
type EditorTarget,
type EditorView,
type NavigationAction,
type NavigationState,
} from './navigation'
@@ -55,6 +58,34 @@ export interface LeaveAnswer {
}
export type CanLeave = (forced: boolean) => LeaveAnswer
/** The layers that can hold a form the user must settle before leaving, top one last. */
const LAYERS = ['citations', 'finding', 'reference'] as const
export type LayerName = (typeof LAYERS)[number]
/** One guard per layer (R2F-1): each layer registers its own check while it is mounted. */
export interface Guards {
register: (layer: LayerName, guard: CanLeave | null) => void
/** The answer of one layer; allowed when the layer registered nothing. */
ask: (layer: LayerName, forced: boolean) => LeaveAnswer
/** The layers asked top down; one refusal refuses, and each one still shows its own. */
askAll: (forced: boolean) => LeaveAnswer
}
/**
* What a move leaves for the history adapter to read once the view has changed: the
* scroll position taken before the dispatch, and whether the move replaces its entry
* (an arrow-key tab move) instead of adding one. The adapter resets it.
*/
export interface MoveTrace {
scrollY: number | null
replace: boolean
}
/** Options of a tab choice. */
export interface SelectOptions {
replace?: boolean
}
type Opener = HTMLElement | null | undefined
export interface EditorNavigation {
@@ -63,7 +94,7 @@ export interface EditorNavigation {
live: string
navigate: (target: EditorTarget) => void
/** False when the open panel refused the tab change (a refused field keeps the page). */
selectTab: (tab: EditorTabId) => boolean
selectTab: (tab: EditorTabId, options?: SelectOptions) => boolean
openSection: (section: AnnotationSection, opener?: Opener) => void
backToDrawing: () => void
/** Opens the citations panel of a finding node; any other key is ignored. */
@@ -78,8 +109,12 @@ export interface EditorNavigation {
exiting: boolean
/** The panel's `onExitComplete`: applies the pending move. */
exitComplete: () => void
/** The panel hands its `canLeave` over while it is mounted (P22''). */
/** The citations panel hands its `canLeave` over while it is mounted (P22''). */
registerCanLeave: (guard: CanLeave | null) => void
guards: Guards
trace: MoveTrace
/** A Back or Forward landed on `view` (the history adapter's way in): no move, no request. */
restoreView: (view: EditorView) => void
consumed: (serial: number, outcome: FocusOutcome) => void
announce: (text: string) => void
}
@@ -87,7 +122,7 @@ export interface EditorNavigation {
const isShown = (element: HTMLElement | null): boolean =>
element !== null && element.isConnected && !element.closest('[hidden]')
const headingOf = (place: PlaceName) =>
export const headingOf = (place: PlaceName) =>
visibleElement(`[data-place="${place}"] [data-place-heading]`)
export const CANVAS_BOX =
@@ -99,14 +134,16 @@ const tabButton = (tab: EditorTabId) =>
document.getElementById(MORE_BUTTON_ID)
/** The place the shown tab and section name. */
function shownPlace(state: NavigationState): PlaceName {
export function shownPlace(
state: Pick<EditorView, 'tab' | 'section'>,
): PlaceName {
return state.tab === 'annotations'
? `annotations.${state.section}`
: state.tab
}
/** The text the live region says for a move to `target`. */
function useMoveText(): (target: EditorTarget) => string {
export function useMoveText(): (target: EditorTarget) => string {
const t = useT()
return useCallback(
(target) => {
@@ -118,14 +155,59 @@ function useMoveText(): (target: EditorTarget) => string {
)
}
/**
* The live region's text. While a modal dialog is open the page is inert and a screen
* reader would drop the message: what is said meanwhile waits, then goes out as ONE
* announcement once the last dialog has closed.
*/
function useLiveRegion() {
const [live, setLive] = useState('')
const queued = useRef<string[]>([])
const announce = useCallback((text: string) => {
setLive((previous) => (previous === text ? `${text} ` : text))
queued.current.push(text)
if (queued.current.length > 1) return
afterModalsClosed(() => {
const joined = queued.current.splice(0).join('. ')
setLive((previous) => (previous === joined ? `${joined} ` : joined))
})
}, [])
return { live, announce }
}
/** The guards of the open layers, keyed by layer so a re-registration keeps its place. */
function useGuards(): Guards {
const guards = useRef(new Map<LayerName, CanLeave>()).current
return useMemo(() => {
const ask = (layer: LayerName, forced: boolean): LeaveAnswer =>
guards.get(layer)?.(forced) ?? { allowed: true }
return {
register: (layer, guard) => {
if (guard) guards.set(layer, guard)
else guards.delete(layer)
},
ask,
askAll: (forced) => {
const answers = [...LAYERS].reverse().map((l) => ask(l, forced))
const notes = answers.flatMap((a) => (a.note ? [a.note] : []))
const note = notes.length > 0 ? notes.join('. ') : undefined
return { allowed: answers.every((a) => a.allowed), note }
},
}
}, [guards])
}
function useMoveTrace() {
const trace = useRef<MoveTrace>({ scrollY: null, replace: false }).current
const mark = useCallback(
(replace = false) => {
trace.scrollY = window.scrollY
trace.replace = replace
},
[trace],
)
return { trace, mark }
}
interface Openers {
/** The trigger that opened the citations panel, and the finding it belongs to. */
citations: RefObject<HTMLElement | null>
@@ -139,25 +221,28 @@ type Go = (action: NavigationAction, kind: MoveKind, text: string) => void
* The one way to move: commit the typed text, announce, dispatch, record the move.
* `finish` is the same without the commit, for the move a closed panel recorded.
*/
function useGo(dispatch: Dispatch<NavigationAction>) {
function useGo(dispatch: Dispatch<NavigationAction>, trace: MoveTrace) {
const { live, announce } = useLiveRegion()
const [move, setMove] = useState<Move | null>(null)
const finish = useCallback(
(move: PendingClose) => {
announce(move.note ? `${move.note}. ${move.text}` : move.text)
trace.scrollY = window.scrollY
dispatch(move.action)
setMove({ kind: move.kind, afterExit: true })
},
[announce, dispatch],
[announce, dispatch, trace],
)
const go: Go = useCallback(
(action, kind, text) => {
commitFocusedField()
announce(text)
trace.scrollY = window.scrollY
trace.replace = false
dispatch(action)
setMove({ kind })
},
[announce, dispatch],
[announce, dispatch, trace],
)
return { move, go, finish, live, announce }
}
@@ -195,7 +280,8 @@ interface PanelContext {
dispatch: Dispatch<NavigationAction>
announce: (text: string) => void
exit: ReturnType<typeof useCitationsExit>
canLeave: RefObject<CanLeave | null>
guards: Guards
mark: (replace?: boolean) => void
}
/**
@@ -204,22 +290,23 @@ interface PanelContext {
* replaces the pending move) and asks nothing: the draft was settled by the first close.
*/
function useRequestClose(ctx: PanelContext) {
const { open, exit, canLeave } = ctx
const { open, exit, guards, mark } = ctx
const { busy, record } = exit
return useCallback(
(move: PendingClose, forced: boolean): boolean => {
if (!open) return true
mark()
if (busy()) {
record(move)
return true
}
commitFocusedField()
const { allowed, note } = canLeave.current?.(forced) ?? { allowed: true }
const { allowed, note } = guards.ask('citations', forced)
if (!allowed) return false
record(note ? { ...move, note } : move)
return true
},
[open, busy, record, canLeave],
[open, busy, record, guards, mark],
)
}
@@ -375,46 +462,53 @@ function useTabSelect(
request: ReturnType<typeof useCloseMoves>['request'],
dispatch: Dispatch<NavigationAction>,
open: boolean,
mark: (replace?: boolean) => void,
) {
const t = useT()
return useCallback(
(tab: EditorTabId): boolean => {
(tab: EditorTabId, options?: SelectOptions): boolean => {
const action = { type: 'select_tab', tab } as const
if (open) {
const text = t(`editor.tab.${tab}`)
return request({ action, kind: 'tab_selected', text }, false)
const allowed = request({ action, kind: 'tab_selected', text }, false)
if (allowed) mark(options?.replace)
return allowed
}
commitFocusedField()
mark(options?.replace)
dispatch(action)
return true
},
[request, dispatch, open, t],
[request, dispatch, open, t, mark],
)
}
/** Navigation of the draft editor: the reducer plus the DOM side (focus, live region). */
export function useEditorNavigation(initialTab: EditorTabId): EditorNavigation {
const [state, dispatch] = useReducer(
navigationReducer,
initialTab,
initialNavigation,
export function useEditorNavigation(
initialTab: EditorTabId,
initialView?: EditorView | null,
): EditorNavigation {
const [state, dispatch] = useReducer(navigationReducer, null, () =>
initialNavigation(initialTab, initialView),
)
const { move, go, finish, live, announce } = useGo(dispatch)
const { trace, mark } = useMoveTrace()
const { move, go, finish, live, announce } = useGo(dispatch, trace)
const openers = useRef<Openers>({
citations: { current: null },
citedBy: { current: null },
section: { current: null },
}).current
const canLeave = useRef<CanLeave | null>(null)
const guards = useGuards()
const exit = useCitationsExit(finish)
const registerCanLeave = useCallback((guard: CanLeave | null) => {
canLeave.current = guard
}, [])
const registerCanLeave = useCallback(
(guard: CanLeave | null) => guards.register('citations', guard),
[guards],
)
const open = state.citationsOf !== null
const receipts = useReceipts(dispatch)
useMoveFocus(move, state, receipts.outcomes, dispatch, openers)
const sections = useSectionMoves(go, openers)
const ctx = { open, go, openers, dispatch, announce, exit, canLeave }
const ctx = { open, go, openers, dispatch, announce, exit, guards, mark }
const openCitations = useOpenCitations(ctx)
const panel = useCloseMoves(ctx)
return {
@@ -422,7 +516,7 @@ export function useEditorNavigation(initialTab: EditorTabId): EditorNavigation {
live,
announce,
consumed: receipts.consumed,
selectTab: useTabSelect(panel.request, dispatch, open),
selectTab: useTabSelect(panel.request, dispatch, open, mark),
openSection: sections.openSection,
backToDrawing: sections.backToDrawing,
navigate: open ? panel.navigate : sections.navigate,
@@ -433,5 +527,11 @@ export function useEditorNavigation(initialTab: EditorTabId): EditorNavigation {
exiting: exit.exiting,
exitComplete: exit.complete,
registerCanLeave,
guards,
trace,
restoreView: useCallback(
(view: EditorView) => dispatch({ type: 'restore_view', view }),
[],
),
}
}
+25 -2
View File
@@ -1,6 +1,15 @@
import { StrictMode } from 'react'
import { render } from '@testing-library/react'
import { MemoryRouter, Route, Routes } from 'react-router-dom'
import {
MemoryRouter,
Route,
Routes,
useLocation,
useNavigate,
type InitialEntry,
type Location,
type NavigateFunction,
} from 'react-router-dom'
import {
SheetFailure,
type OwnCatalogGrant,
@@ -92,6 +101,16 @@ export interface MountOptions {
adminFailure?: SheetFailureKind
/** Renders inside <StrictMode>: effects run twice on mount, as in development. */
strict?: boolean
/** The router's history before the draft: the draft is the last entry (default: only it). */
entries?: InitialEntry[]
/** Called on every render with the router's navigate and location: Back, Forward, state. */
probe?: (navigate: NavigateFunction, location: Location) => void
}
/** Hands the router to a test: MemoryRouter listens to no popstate, a test calls navigate(-1). */
function RouterProbe({ probe }: { probe: NonNullable<MountOptions['probe']> }) {
probe(useNavigate(), useLocation())
return null
}
/** Mounts the draft route as an editor with the admin role, at a wide screen, by default. */
@@ -115,7 +134,11 @@ export function mountDraft(options: MountOptions = {}) {
)
}
const page = (
<MemoryRouter initialEntries={[`/app/admin/sheets/${SHEET}/draft`]}>
<MemoryRouter
initialEntries={options.entries ?? [`/app/admin/sheets/${SHEET}/draft`]}
initialIndex={options.entries ? options.entries.length - 1 : undefined}
>
{options.probe && <RouterProbe probe={options.probe} />}
<Routes>
<Route
path="/app/admin/sheets/:sheetId/draft"
@@ -0,0 +1,154 @@
/** R2F-1: the history entry, its ownership, the write plan and the write budget. */
import { describe, expect, it } from 'vitest'
import {
createWriteBudget,
ENTRY_KEY,
layerCount,
ownedEntry,
planWrite,
readEntry,
sanitizeView,
type HistoryEntry,
} from '@/editor/history/entry'
import {
defaultView,
initialNavigation,
navigationReducer,
sameView,
viewOf,
type EditorView,
} from '@/editor/navigation'
const view = (tab: EditorView['tab'], patch: Partial<EditorView> = {}) => ({
...defaultView(tab),
...patch,
})
const entry = (patch: Partial<HistoryEntry> = {}): HistoryEntry => ({
id: 'e1',
view: view('general'),
below: null,
sheetId: 'S',
userId: 'U',
...patch,
})
const stateOf = (value: unknown) => ({ [ENTRY_KEY]: value })
describe('sanitizeView', () => {
it('keeps a tab and a section, and holds no layer yet', () => {
const raw = { tab: 'annotations', section: 'views', finding: { key: {} } }
expect(sanitizeView(raw)).toEqual(view('annotations', { section: 'views' }))
})
it('drops what is no view: an unknown tab, a non-object', () => {
expect(sanitizeView({ tab: 'nowhere', section: 'views' })).toBeNull()
expect(sanitizeView('general')).toBeNull()
expect(sanitizeView(null)).toBeNull()
})
it('falls back to the drawing on an unknown section', () => {
expect(sanitizeView({ tab: 'annotations', section: 'x' })?.section).toBe(
'drawing',
)
})
})
describe('readEntry and ownership', () => {
it('reads a well-formed entry and nothing else', () => {
expect(readEntry(stateOf(entry()))).toEqual(entry())
expect(readEntry(null)).toBeNull()
expect(readEntry({})).toBeNull()
expect(readEntry(stateOf({ ...entry(), id: 3 }))).toBeNull()
expect(readEntry(stateOf({ ...entry(), view: 'x' }))).toBeNull()
})
it('restores only for the sheet and the account that wrote it', () => {
const mine = { sheetId: 'S', userId: 'U' }
expect(ownedEntry(stateOf(entry()), mine)).not.toBeNull()
expect(ownedEntry(stateOf(entry()), { ...mine, sheetId: 'T' })).toBeNull()
expect(ownedEntry(stateOf(entry()), { ...mine, userId: 'V' })).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')
})
})
describe('planWrite', () => {
const top = entry({ view: view('general'), below: null })
it('does nothing for the same view', () => {
expect(planWrite(top, view('general'), false)).toBe('none')
// a section only counts on Annotations
const other = view('general', { section: 'views' })
expect(planWrite(top, other, false)).toBe('none')
})
it('pushes an added tab or section, replaces on a replace hint', () => {
expect(planWrite(top, view('findings'), false)).toBe('push')
expect(planWrite(top, view('findings'), true)).toBe('replace')
const onAnnotations = entry({ view: view('annotations') })
const views = view('annotations', { section: 'views' })
expect(planWrite(onAnnotations, views, 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') })
expect(layerCount(layer)).toBe(1)
expect(planWrite(opened, view('findings'), false)).toBe('back')
})
it('replaces a layer removed when the entry below is another view', () => {
const layer = view('findings', { reference: { create: true } })
const opened = entry({ view: layer, below: view('general') })
expect(planWrite(opened, view('findings'), false)).toBe('replace')
expect(planWrite(entry({ view: layer }), view('findings'), false)).toBe(
'replace',
)
})
})
describe('createWriteBudget', () => {
it('lets the limit through per window, then refuses until the window slides', () => {
const take = createWriteBudget(3, 1000)
expect([0, 100, 200].map(take)).toEqual([true, true, true])
expect(take(300)).toBe(false)
expect(take(999)).toBe(false)
expect(take(1000)).toBe(true)
})
})
describe('the view the reducer holds', () => {
it('restore_view lands on a view without a move or a focus request', () => {
const state = initialNavigation('general')
const next = navigationReducer(state, {
type: 'restore_view',
view: view('annotations', { section: 'regions' }),
})
expect(viewOf(next)).toEqual(view('annotations', { section: 'regions' }))
expect(next.focus).toBeUndefined()
expect(next.visitedSections).toContain('regions')
})
it('keeps the remembered section when the view is on another tab', () => {
const base = navigationReducer(initialNavigation('annotations'), {
type: 'open_section',
section: 'views',
})
const next = navigationReducer(base, {
type: 'restore_view',
view: view('general'),
})
expect(next.section).toBe('views')
expect(
sameView(viewOf(next), view('general', { section: 'drawing' })),
).toBe(true)
})
it('opens the state on a view read at mount', () => {
const state = initialNavigation('annotations', view('findings'))
expect(state.tab).toBe('findings')
expect(state.visitedTabs).toEqual(['findings'])
})
})
@@ -0,0 +1,144 @@
/** R2F-1/2: guard stack, announcer queue, a Back refused while the citations panel is open. */
import { afterEach, describe, expect, it, vi } from 'vitest'
import {
act,
cleanup,
render,
renderHook,
screen,
} from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import type { ElementKey } from '@faunosteo/core-wasm/types'
import {
MemoryRouter,
useLocation,
useNavigate,
type Location,
type NavigateFunction,
} from 'react-router-dom'
import { flushAfterModals } from '@/components/ui/afterModalsClosed'
import { useBeforeUnload } from '@/app/useLeaveGuard'
import EditorTabs from '@/components/editor/EditorTabs'
import { ENTRY_KEY, type HistoryEntry } from '@/editor/history/entry'
import useEditorHistory from '@/editor/history/useEditorHistory'
import { defaultView } from '@/editor/navigation'
import { useEditorNavigation } from '@/editor/useEditorNavigation'
import { useLocaleStore } from '@/state/localeStore'
afterEach(cleanup)
const owner = { sheetId: 'S', userId: 'U' }
const finding: ElementKey = {
kind: 'finding',
zone_id: 'zone',
path: ['family', 'node'],
}
let navigate: NavigateFunction
let location: Location
const entry = () => (location.state as Record<string, HistoryEntry>)[ENTRY_KEY]
function Page({ guard }: { guard?: () => { allowed: boolean } }) {
const nav = useEditorNavigation('general')
navigate = useNavigate()
location = useLocation()
useEditorHistory(nav, owner, defaultView('general'))
return (
<>
<EditorTabs active={nav.state.tab} tier="wide" onSelect={nav.selectTab} />
<button onClick={() => nav.openCitations(finding)}>cite</button>
<button onClick={() => nav.registerCanLeave(guard ?? null)}>guard</button>
<button onClick={() => nav.announce('one')}>say one</button>
<button onClick={() => nav.announce('two')}>say two</button>
<p data-testid="live">{nav.live}</p>
</>
)
}
const mount = (guard?: () => { allowed: boolean }) =>
render(
<MemoryRouter initialEntries={['/x']}>
<Page guard={guard} />
</MemoryRouter>,
)
describe('a Back while the citations panel is open', () => {
it('keeps the page where it is, asks the dirty layer, and pushes the view again', async () => {
useLocaleStore.setState({ locale: 'fr' })
const user = userEvent.setup()
const guard = vi.fn(() => ({ allowed: false }))
mount(guard)
await user.click(screen.getByRole('button', { name: 'guard' }))
await user.click(screen.getByRole('tab', { name: 'Constats' }))
await user.click(screen.getByRole('button', { name: 'cite' }))
const before = entry().id
act(() => navigate(-1))
expect(guard).toHaveBeenCalledWith(false)
expect(screen.getByRole('tab', { selected: true })).toHaveTextContent(
'Constats',
)
expect(entry().id).not.toBe(before)
expect(entry().view.tab).toBe('findings')
expect(entry().below?.tab).toBe('general')
})
})
describe('the guard stack', () => {
it('asks each layer on its own, and all of them top down', () => {
const { result } = renderHook(() => useEditorNavigation('general'))
const { guards } = result.current
const order: string[] = []
guards.register('citations', () => {
order.push('citations')
return { allowed: true, note: 'a' }
})
guards.register('finding', () => {
order.push('finding')
return { allowed: false, note: 'b' }
})
expect(guards.ask('reference', false)).toEqual({ allowed: true })
expect(guards.ask('finding', true).allowed).toBe(false)
order.length = 0
expect(guards.askAll(false)).toEqual({ allowed: false, note: 'b. a' })
expect(order).toEqual(['finding', 'citations'])
guards.register('finding', null)
expect(guards.askAll(false).allowed).toBe(true)
})
})
describe('the announcer', () => {
it('says what is announced at once while no dialog is open', async () => {
mount()
await userEvent.click(screen.getByRole('button', { name: 'say one' }))
expect(screen.getByTestId('live')).toHaveTextContent('one')
})
it('joins what is announced under an open dialog into one announcement', 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' }))
await user.click(screen.getByRole('button', { name: 'say two' }))
expect(screen.getByTestId('live')).toHaveTextContent('')
dialog.remove()
act(() => flushAfterModals())
expect(screen.getByTestId('live')).toHaveTextContent('one. two')
})
})
describe('useBeforeUnload', () => {
it('asks while dirty and stops when clean', () => {
const { rerender } = renderHook(({ dirty }) => useBeforeUnload(dirty), {
initialProps: { dirty: true },
})
const first = new Event('beforeunload', { cancelable: true })
window.dispatchEvent(first)
expect(first.defaultPrevented).toBe(true)
rerender({ dirty: false })
const second = new Event('beforeunload', { cancelable: true })
window.dispatchEvent(second)
expect(second.defaultPrevented).toBe(false)
})
})
+193
View File
@@ -0,0 +1,193 @@
/** R2F-1: the browser history follows tab, section and « Aller à » moves (MemoryRouter). */
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import {
act,
cleanup,
fireEvent,
screen,
waitFor,
} from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import type { Location, NavigateFunction } from 'react-router-dom'
import { ENTRY_KEY, type HistoryEntry } from '@/editor/history/entry'
import { defaultView } from '@/editor/navigation'
import { useLocaleStore } from '@/state/localeStore'
import { emptyText } from '../helpers/editorFixtures'
import { resetStore, serverHas, SHEET, USER } from '../helpers/editorHarness'
import { mountDraft, setWidth } from '../helpers/editorRoute'
vi.mock('@/lib/supabase', () => ({ getSupabaseClient: () => ({}) }))
vi.mock('@faunosteo/supabase', async (orig) => ({
...(await orig<typeof import('@faunosteo/supabase')>()),
getSheetVersion: vi.fn(),
downloadSheetDrawing: vi.fn(),
saveSheetDraft: vi.fn(),
getOfficialSheetAdmin: vi.fn(),
submitSheetReview: vi.fn(),
}))
let navigate: NavigateFunction
let location: Location
const probe = (n: NavigateFunction, l: Location) => {
navigate = n
location = l
}
const written = () =>
(location.state as Record<string, HistoryEntry> | null)?.[ENTRY_KEY]
const ready = () =>
screen.findByRole('heading', { level: 1, name: 'Brouillon, version 4' })
const tab = (name: string) => screen.getByRole('tab', { name })
const selected = () =>
screen.getByRole('tab', { selected: true }).textContent ?? ''
const back = (delta = -1) => act(() => navigate(delta))
const path = `/app/admin/sheets/${SHEET}/draft`
const foreign = (patch: Partial<HistoryEntry>) => ({
[ENTRY_KEY]: {
id: 'old',
view: defaultView('findings'),
below: null,
sheetId: SHEET,
userId: USER,
...patch,
},
})
beforeEach(() => {
useLocaleStore.setState({ locale: 'fr' })
serverHas(emptyText(), 3, false)
})
afterEach(() => {
cleanup()
resetStore()
setWidth(1024)
})
describe('mount', () => {
it('writes the default view as the first entry', async () => {
mountDraft({ probe })
await ready()
await waitFor(() => expect(written()).toBeTruthy())
const tabs: Record<string, string> = {
Général: 'general',
Annotations: 'annotations',
}
expect(written()?.view.tab).toBe(tabs[selected()])
expect(written()).toMatchObject({
sheetId: SHEET,
userId: USER,
below: null,
})
})
it('restores the view of an entry of this sheet and account', async () => {
const entries = [{ pathname: path, state: foreign({}) }]
mountDraft({ probe, entries })
await ready()
expect(selected()).toBe('Constats')
expect(written()?.id).toBe('old')
})
it('replaces an entry of another sheet or account by the default view', async () => {
const entries = [{ pathname: path, state: foreign({ sheetId: 'other' }) }]
mountDraft({ probe, entries })
await ready()
await waitFor(() => expect(written()?.sheetId).toBe(SHEET))
expect(selected()).not.toBe('Constats')
expect(written()?.id).not.toBe('old')
})
})
describe('tab and section moves', () => {
it('a tab click pushes, Back and Forward restore it, the tab button holds the focus', async () => {
const user = userEvent.setup()
mountDraft({ probe })
await ready()
await waitFor(() => expect(written()).toBeTruthy())
const first = selected()
await user.click(tab('Constats'))
await waitFor(() => expect(written()?.view.tab).toBe('findings'))
expect(written()?.below?.tab).not.toBe('findings')
back()
await waitFor(() => expect(selected()).toBe(first))
await waitFor(() => expect(document.activeElement).toBe(tab(first)))
back(1)
await waitFor(() => expect(selected()).toBe('Constats'))
await waitFor(() => expect(document.activeElement).toBe(tab('Constats')))
})
it('arrow keys along the row replace the entry instead of adding one', async () => {
const user = userEvent.setup()
mountDraft({ probe, entries: ['/app/admin', path] })
await ready()
await user.click(tab('Constats'))
await waitFor(() => expect(written()?.view.tab).toBe('findings'))
tab('Constats').focus()
fireEvent.keyDown(tab('Constats'), { key: 'ArrowRight' })
await waitFor(() => expect(selected()).toBe('Références'))
expect(written()?.view.tab).toBe('references')
// one Back leaves the replaced entry for the one below it, not for « Constats »
back()
await waitFor(() => expect(selected()).not.toBe('Références'))
expect(selected()).not.toBe('Constats')
})
it('an Annotations section pushes, « Retour au dessin » too, Back returns to the section', async () => {
const user = userEvent.setup()
mountDraft({ probe })
await ready()
await user.click(tab('Annotations'))
await user.click(screen.getByRole('button', { name: 'Vues' }))
await waitFor(() => expect(written()?.view.section).toBe('views'))
await user.click(screen.getByRole('button', { name: 'Retour au dessin' }))
await waitFor(() => expect(written()?.view.section).toBe('drawing'))
back()
await waitFor(() =>
expect(
screen.getByRole('button', { name: 'Retour au dessin' }),
).toBeVisible(),
)
expect(written()?.view.section).toBe('views')
})
it('a move that changes nothing writes nothing', async () => {
const user = userEvent.setup()
mountDraft({ probe })
await ready()
await waitFor(() => expect(written()).toBeTruthy())
const before = location.key
await user.click(screen.getByRole('tab', { selected: true }))
expect(location.key).toBe(before)
})
})
describe('a Back that must not unmount what is on screen', () => {
it('keeps the view and pushes it again while a dialog is open', async () => {
const user = userEvent.setup()
mountDraft({ probe })
await ready()
await user.click(tab('Constats'))
await waitFor(() => expect(written()?.view.tab).toBe('findings'))
const dialog = document.createElement('dialog')
dialog.setAttribute('open', '')
document.body.append(dialog)
back()
await waitFor(() => expect(written()?.view.tab).toBe('findings'))
expect(selected()).toBe('Constats')
// the re-pushed entry sits above the one landed on
expect(written()?.below?.tab).not.toBe('findings')
dialog.remove()
})
})
describe('StrictMode', () => {
it('writes the first entry once', async () => {
mountDraft({ probe, strict: true })
await ready()
await waitFor(() => expect(written()).toBeTruthy())
const id = written()?.id
expect(id).toBeTruthy()
await new Promise((resolve) => setTimeout(resolve, 20))
expect(written()?.id).toBe(id)
})
})