fix(editor): view row reveal survives a reversed slide; double click ignored

This commit is contained in:
bchanot committed 2026-11-21 22:52:44 +01:00
1 parent 295413c5f9
commit bc82cd63b6
4 files changed
+286 -55

No files matched your search

@@ -4,7 +4,7 @@ import type { SheetView } from '@faunosteo/core-wasm/types'
import Icon from '@/components/ui/Icon' import Icon from '@/components/ui/Icon'
import { useT } from '@/i18n/useT' import { useT } from '@/i18n/useT'
import { useLocaleStore } from '@/state/localeStore' import { useLocaleStore } from '@/state/localeStore'
import { useViewRow } from './viewRow' import { chipOf, useViewRow } from './viewRow'
import type { HintState } from './viewRow' import type { HintState } from './viewRow'
const PILL = const PILL =
@@ -28,7 +28,10 @@ const DOT =
'absolute -right-0.5 -top-0.5 h-2.5 w-2.5 rounded-full bg-[var(--color-ink)] ' + 'absolute -right-0.5 -top-0.5 h-2.5 w-2.5 rounded-full bg-[var(--color-ink)] ' +
'ring-2 ring-white' 'ring-2 ring-white'
/** `:focus-visible` is unsupported in some environments (happy-dom): then not keyboard. */ /**
* Whether the chip took a keyboard focus. happy-dom treats `:focus-visible` as `:focus`; the
* try/catch is for engines that throw on the selector (then: not keyboard).
*/
function isKeyboardFocus(element: HTMLElement): boolean { function isKeyboardFocus(element: HTMLElement): boolean {
try { try {
return element.matches(':focus-visible') return element.matches(':focus-visible')
@@ -120,7 +123,10 @@ export default function ViewSwitcher({
} }
const onKeyDown = (event: KeyboardEvent<HTMLElement>) => { const onKeyDown = (event: KeyboardEvent<HTMLElement>) => {
if (event.altKey || event.ctrlKey || event.metaKey) return if (event.altKey || event.ctrlKey || event.metaKey) return
const at = views.findIndex((view) => view.id === tabStop) const target = event.target as HTMLElement
const from =
target.closest<HTMLElement>('[data-view-chip]')?.dataset.viewChip
const at = views.findIndex((view) => view.id === (from ?? tabStop))
const last = views.length - 1 const last = views.length - 1
const to = { const to = {
ArrowRight: Math.min(at + 1, last), ArrowRight: Math.min(at + 1, last),
@@ -131,11 +137,8 @@ export default function ViewSwitcher({
if (to === undefined || views.length === 0) return if (to === undefined || views.length === 0) return
event.preventDefault() event.preventDefault()
const id = views[to].id const id = views[to].id
const chips = const row = rowRef.current
rowRef.current?.querySelectorAll<HTMLElement>('[data-view-chip]') if (row) chipOf(row, id)?.focus({ preventScroll: true })
Array.from(chips ?? [])
.find((chip) => chip.dataset.viewChip === id)
?.focus({ preventScroll: true })
reveal(id) reveal(id)
} }
const press = (side: 'start' | 'end') => const press = (side: 'start' | 'end') =>
@@ -163,7 +166,11 @@ export default function ViewSwitcher({
tabIndex={tabStop === view.id ? 0 : -1} tabIndex={tabStop === view.id ? 0 : -1}
data-view-chip={view.id} data-view-chip={view.id}
onClick={(event) => onClick={(event) =>
view.id !== current && onSelect(view.id, event.currentTarget) // A repeated click (detail > 1) is dropped: the row may have moved
// under the pointer after the first, and the second would hit a neighbour.
event.detail <= 1 &&
view.id !== current &&
onSelect(view.id, event.currentTarget)
} }
className="group h-11 shrink-0 px-1 outline-none" className="group h-11 shrink-0 px-1 outline-none"
> >
@@ -68,7 +68,7 @@ export function hintState(
return { start, end, dot } return { start, end, dot }
} }
function chipOf(row: HTMLElement, id: string): HTMLElement | null { export function chipOf(row: HTMLElement, id: string): HTMLElement | null {
const chips = row.querySelectorAll<HTMLElement>('[data-view-chip]') const chips = row.querySelectorAll<HTMLElement>('[data-view-chip]')
return Array.from(chips).find((chip) => chip.dataset.viewChip === id) ?? null return Array.from(chips).find((chip) => chip.dataset.viewChip === id) ?? null
} }
@@ -124,27 +124,51 @@ export function useViewRow(
const currentRef = useRef(current) const currentRef = useRef(current)
currentRef.current = current currentRef.current = current
/**
* Where a smooth slide in flight will land, null when none: a reveal is judged against
* it, not against the instantaneous `scrollLeft` (a chip clear at the moment may not be
* once the slide ends).
*/
const pending = useRef<number | null>(null)
const slideTo = useCallback(
(row: HTMLElement, left: number, instant: boolean) => {
const slides = !instant && Math.abs(left - row.scrollLeft) >= 1
pending.current = slides ? left : null
row.scrollTo({ left, behavior: instant ? 'auto' : 'smooth' })
},
[],
)
const reveal = useCallback( const reveal = useCallback(
(id: string) => { (id: string, now = false) => {
const row = rowRef.current const row = rowRef.current
const chip = row && chipOf(row, id) const chip = row && chipOf(row, id)
if (!row || !chip) return if (!row || !chip) return
const left = revealLeft(row, spanOf(row, chip)) const left = revealLeft(
{
scrollLeft: pending.current ?? row.scrollLeft,
clientWidth: row.clientWidth,
scrollWidth: row.scrollWidth,
},
spanOf(row, chip),
)
if (left === null) return if (left === null) return
const instant = opening.current || reduced slideTo(row, left, now || opening.current || !!reduced)
row.scrollTo({ left, behavior: instant ? 'auto' : 'smooth' })
}, },
[rowRef, reduced], [rowRef, reduced, slideTo],
) )
const page = useCallback( const page = useCallback(
(direction: 1 | -1) => { (direction: 1 | -1) => {
const row = rowRef.current const row = rowRef.current
if (!row) return if (!row) return
const left = direction * PAGE_SHARE * row.clientWidth const from = pending.current ?? row.scrollLeft
row.scrollBy({ left, behavior: reduced ? 'auto' : 'smooth' }) const max = row.scrollWidth - row.clientWidth
const left = from + direction * PAGE_SHARE * row.clientWidth
slideTo(row, Math.min(Math.max(left, 0), max), !!reduced)
}, },
[rowRef, reduced], [rowRef, reduced, slideTo],
) )
const revealRef = useRef(reveal) const revealRef = useRef(reveal)
@@ -163,26 +187,53 @@ export function useViewRow(
refresh() refresh()
}, [refresh, namesKey]) }, [refresh, namesKey])
// New names change the chip widths: the active chip is put back at once, like the opening.
const names = useRef(namesKey)
useLayoutEffect(() => {
if (names.current === namesKey) return
names.current = namesKey
revealRef.current(currentRef.current, true)
}, [namesKey])
useEffect(() => { useEffect(() => {
const row = rowRef.current const row = rowRef.current
if (!row) return if (!row) return
const onScroll = () => refreshRef.current() const settled = () => {
pending.current = null
}
const onScroll = () => {
const target = pending.current
if (target !== null && Math.abs(row.scrollLeft - target) < 1) settled()
refreshRef.current()
}
// The user takes the row over, or the slide ends where `scrollend` exists.
// shortcut: an engine without `scrollend` whose slide is cut short by something other
// than these events keeps a stale target until the row next reaches it.
const takeovers = ['wheel', 'touchstart', 'pointerdown', 'scrollend']
row.addEventListener('scroll', onScroll, { passive: true }) row.addEventListener('scroll', onScroll, { passive: true })
if (typeof ResizeObserver === 'undefined') for (const type of takeovers) row.addEventListener(type, settled)
return () => row.removeEventListener('scroll', onScroll) const detach = () => {
row.removeEventListener('scroll', onScroll)
for (const type of takeovers) row.removeEventListener(type, settled)
}
if (typeof ResizeObserver === 'undefined') return detach
let width = row.clientWidth let width = row.clientWidth
const observer = new ResizeObserver(() => { const observer = new ResizeObserver(() => {
if (width === 0 && row.clientWidth > 0) { const shown = width === 0 && row.clientWidth > 0
openWindow() if (shown) openWindow()
// A view that changed while the row was hidden had nothing to reveal. // A view that changed while the row was hidden had nothing to reveal; a new width
revealRef.current(currentRef.current) // moves the chip edges the same way.
} if (
shown ||
(width > 0 && row.clientWidth > 0 && row.clientWidth !== width)
)
revealRef.current(currentRef.current, true)
width = row.clientWidth width = row.clientWidth
refreshRef.current() refreshRef.current()
}) })
observer.observe(row) observer.observe(row)
return () => { return () => {
row.removeEventListener('scroll', onScroll) detach()
observer.disconnect() observer.disconnect()
} }
}, [rowRef, openWindow]) }, [rowRef, openWindow])
+3 -2
View File
@@ -45,8 +45,9 @@ body,
while another section shows, and the strip is sticky from 1 024 px only. Where the while another section shows, and the strip is sticky from 1 024 px only. Where the
drawing column is pinned (block below), its controls take the bar's margin instead. drawing column is pinned (block below), its controls take the bar's margin instead.
The chip row is scrolled sideways, not by these margins: its own `scroll-padding-inline: The chip row is scrolled sideways, not by these margins: its own `scroll-padding-inline:
72px` (the fade width) keeps a chip the browser focus-scrolls into view, a Tab entry for 72px` (the fade width) helps a chip that is fully hidden when the browser focus-scrolls it
one, clear of the fades in this Chromium; other browsers do it best effort. */ into view; a chip only partly under a fade is not scrolled by the browser, so the
`:focus-visible` reveal in `viewRow.ts` covers it. Other browsers do it best effort. */
@media (min-width: 1024px) { @media (min-width: 1024px) {
[data-place='annotations.drawing']:not([hidden]) [data-place='annotations.drawing']:not([hidden])
:is( :is(
+198 -26
View File
@@ -1,5 +1,5 @@
/** U2 criterion 32: the view chips in one scrolling row (roving tab stop, hints, reveal). */ /** U2 criterion 32: the view chips in one scrolling row (roving tab stop, hints, reveal). */
import '../helpers/motion' import { setReducedMotion } from '../helpers/motion'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { import {
act, act,
@@ -62,13 +62,20 @@ function renderRow(onSelect = vi.fn(), views = viewsOf(), current = 'v3') {
} }
} }
const originalScrollTo = Element.prototype.scrollTo
beforeEach(() => useLocaleStore.setState({ locale: 'fr' })) beforeEach(() => useLocaleStore.setState({ locale: 'fr' }))
afterEach(() => { afterEach(() => {
cleanup() cleanup()
resetStore() resetStore()
resetWork() resetWork()
setReducedMotion(false)
vi.useRealTimers() vi.useRealTimers()
delete (Element.prototype as unknown as Record<string, unknown>).scrollTo Object.defineProperty(Element.prototype, 'scrollTo', {
configurable: true,
writable: true,
value: originalScrollTo,
})
}) })
describe('the roving tab stop and the keys', () => { describe('the roving tab stop and the keys', () => {
@@ -123,6 +130,22 @@ describe('the roving tab stop and the keys', () => {
expect(onSelect).not.toHaveBeenCalled() expect(onSelect).not.toHaveBeenCalled()
}) })
it('drops a repeated click (detail above 1): the row may have moved under it', () => {
const { onSelect } = renderRow()
fireEvent.click(chip('Vue 2'), { detail: 2 })
expect(onSelect).not.toHaveBeenCalled()
fireEvent.click(chip('Vue 2'), { detail: 0 })
fireEvent.click(chip('Vue 4'), { detail: 1 })
expect(onSelect).toHaveBeenCalledTimes(2)
})
it('starts an arrow from the chip that has the focus, not from the tab stop', () => {
renderRow()
// The tab stop is the active chip (Vue 3); the key comes from another chip.
fireEvent.keyDown(chip('Vue 5'), { key: 'ArrowLeft' })
expect(chip('Vue 4')).toHaveFocus()
})
it('puts the tab stop back on the active chip when the focus leaves', async () => { it('puts the tab stop back on the active chip when the focus leaves', async () => {
renderRow() renderRow()
act(() => chip('Vue 3').focus()) act(() => chip('Vue 3').focus())
@@ -171,8 +194,15 @@ describe('the chips and their hints', () => {
}) })
}) })
/** Row geometry: 300 px wide showing 900 of content, each chip 100 px. */ /**
function stubGeometry(scrollWidth = 900, clientWidth = 300) { * Row geometry: 300 px wide showing 900 of content, each chip 100 px. `scrolled` reads the
* row's instantaneous `scrollLeft`, which the chip boxes follow like in a browser.
*/
function stubGeometry(
scrollWidth = 900,
clientWidth = 300,
scrolled = () => 0,
) {
const row = toolbar() const row = toolbar()
Object.defineProperty(row, 'clientWidth', { Object.defineProperty(row, 'clientWidth', {
configurable: true, configurable: true,
@@ -182,13 +212,42 @@ function stubGeometry(scrollWidth = 900, clientWidth = 300) {
configurable: true, configurable: true,
value: scrollWidth, value: scrollWidth,
}) })
Object.defineProperty(row, 'scrollLeft', {
configurable: true,
get: scrolled,
})
row.getBoundingClientRect = () => ({ left: 0, right: clientWidth }) as DOMRect row.getBoundingClientRect = () => ({ left: 0, right: clientWidth }) as DOMRect
chips().forEach((c, index) => { chips().forEach((c, index) => {
c.getBoundingClientRect = () => c.getBoundingClientRect = () =>
({ left: index * 100, right: index * 100 + 100 }) as DOMRect ({
left: index * 100 - scrolled(),
right: index * 100 + 100 - scrolled(),
}) as DOMRect
}) })
} }
/** The ResizeObserver callbacks of the mounted rows; `restore` puts the original back. */
function stubResizeObserver() {
const original = globalThis.ResizeObserver
const callbacks: Array<() => void> = []
vi.stubGlobal(
'ResizeObserver',
class {
constructor(callback: () => void) {
callbacks.push(callback)
}
observe() {}
disconnect() {}
},
)
return {
resize: () => act(() => callbacks.forEach((callback) => callback())),
restore: () => {
globalThis.ResizeObserver = original
},
}
}
describe('the reveal of the active chip', () => { describe('the reveal of the active chip', () => {
let scrollTo: ReturnType<typeof vi.fn> let scrollTo: ReturnType<typeof vi.fn>
beforeEach(() => { beforeEach(() => {
@@ -219,31 +278,65 @@ describe('the reveal of the active chip', () => {
}) })
it('reveals the active chip when the row is shown again', () => { it('reveals the active chip when the row is shown again', () => {
const original = globalThis.ResizeObserver const observer = stubResizeObserver()
const observers: Array<() => void> = [] try {
vi.stubGlobal( vi.useFakeTimers()
'ResizeObserver', const { again } = renderRow(vi.fn(), viewsOf(), 'v1')
class { act(() => void vi.advanceTimersByTime(OPENING_MS + 1))
constructor(callback: () => void) { // Hidden: width 0, the change reveals nothing.
observers.push(callback) stubGeometry(0, 0)
} again({ current: 'v5' })
observe() {} expect(scrollTo).not.toHaveBeenCalled()
disconnect() {} // Shown again: the chip (400 to 500) is past the end hint of a 300 px row.
}, stubGeometry()
) observer.resize()
expect(scrollTo).toHaveBeenCalledTimes(1)
expect(scrollTo).toHaveBeenCalledWith({ left: 272, behavior: 'auto' })
} finally {
observer.restore()
}
})
it('puts the active chip back at once when the row width changes', () => {
const observer = stubResizeObserver()
try {
vi.useFakeTimers()
renderRow(vi.fn(), viewsOf(), 'v5')
stubGeometry()
observer.resize()
act(() => void vi.advanceTimersByTime(OPENING_MS + 1))
scrollTo.mockClear()
// 250 px wide: the chip (400 to 500) lands 72 px from the end of the new width.
stubGeometry(900, 250)
observer.resize()
expect(scrollTo).toHaveBeenCalledTimes(1)
expect(scrollTo).toHaveBeenCalledWith({ left: 322, behavior: 'auto' })
} finally {
observer.restore()
}
})
it('puts the active chip back at once when a language switch changes the names', () => {
vi.useFakeTimers()
renderRow(vi.fn(), viewsOf(), 'v5')
act(() => void vi.advanceTimersByTime(OPENING_MS + 1))
stubGeometry()
scrollTo.mockClear()
act(() => useLocaleStore.setState({ locale: 'en' }))
expect(scrollTo).toHaveBeenCalledTimes(1)
expect(scrollTo).toHaveBeenCalledWith({ left: 272, behavior: 'auto' })
})
it('slides with `auto` under reduced motion, for a reveal and for a page', () => {
setReducedMotion(true)
vi.useFakeTimers() vi.useFakeTimers()
const { again } = renderRow(vi.fn(), viewsOf(), 'v1') const { again } = renderRow(vi.fn(), viewsOf(), 'v1')
act(() => void vi.advanceTimersByTime(OPENING_MS + 1)) act(() => void vi.advanceTimersByTime(OPENING_MS + 1))
// Hidden: width 0, the change reveals nothing.
stubGeometry(0, 0)
again({ current: 'v5' })
expect(scrollTo).not.toHaveBeenCalled()
// Shown again: the chip (400 to 500) is past the end hint of a 300 px row.
stubGeometry() stubGeometry()
act(() => observers.forEach((callback) => callback())) fireEvent.click(screen.getByTitle('Vues suivantes'))
expect(scrollTo).toHaveBeenCalledTimes(1) expect(scrollTo).toHaveBeenLastCalledWith({ left: 240, behavior: 'auto' })
expect(scrollTo).toHaveBeenCalledWith({ left: 272, behavior: 'auto' }) again({ current: 'v5' })
globalThis.ResizeObserver = original expect(scrollTo).toHaveBeenLastCalledWith({ left: 272, behavior: 'auto' })
}) })
it('shows the end hint again when a name change widens the content', () => { it('shows the end hint again when a name change widens the content', () => {
@@ -259,6 +352,85 @@ describe('the reveal of the active chip', () => {
}) })
}) })
describe('a reveal while a slide is in flight', () => {
let scrollTo: ReturnType<typeof vi.fn>
let scrolled: number
beforeEach(() => {
scrollTo = vi.fn()
scrolled = 0
Object.defineProperty(Element.prototype, 'scrollTo', {
configurable: true,
value: scrollTo,
})
vi.useFakeTimers()
})
/** Focus on Vue 1, geometry stubbed past the opening window, then four arrows right. */
function arrowsToTheFourth() {
renderRow(vi.fn(), viewsOf(), 'v1')
act(() => void vi.advanceTimersByTime(OPENING_MS + 1))
stubGeometry(900, 300, () => scrolled)
act(() => chip('Vue 1').focus())
for (let n = 0; n < 4; n++)
fireEvent.keyDown(document.activeElement!, { key: 'ArrowRight' })
expect(chip('Vue 5')).toHaveFocus()
// Each chip past the end hint retargets the slide: the last lands on 272.
expect(scrollTo).toHaveBeenLastCalledWith({ left: 272, behavior: 'smooth' })
}
it('judges the chip against where the slide lands: a reversed arrow stops it short', () => {
arrowsToTheFourth()
// Mid-flight at 200 the fourth chip (300 to 400) is clear, but at 272 it is not.
scrolled = 200
fireEvent.keyDown(chip('Vue 5'), { key: 'ArrowLeft' })
expect(chip('Vue 4')).toHaveFocus()
expect(scrollTo).toHaveBeenLastCalledWith({ left: 228, behavior: 'smooth' })
})
it('leaves a slide that already brings the chip clear alone', () => {
arrowsToTheFourth()
scrollTo.mockClear()
// The fifth chip (400 to 500) is the one the slide ends on.
fireEvent.keyDown(chip('Vue 5'), { key: 'ArrowRight' })
expect(scrollTo).not.toHaveBeenCalled()
})
it.each([
[
'the slide ends (scrollend)',
() => fireEvent(toolbar(), new Event('scrollend')),
],
['the user takes the row (wheel)', () => fireEvent.wheel(toolbar())],
[
'the row reaches its target',
() => {
scrolled = 272
fireEvent.scroll(toolbar())
scrolled = 200
},
],
])('judges against the instantaneous position once %s', (_name, end) => {
arrowsToTheFourth()
scrolled = 200
end()
scrollTo.mockClear()
// At rest on 200 the fourth chip (300 to 400) is clear: nothing to do.
fireEvent.keyDown(chip('Vue 5'), { key: 'ArrowLeft' })
expect(scrollTo).not.toHaveBeenCalled()
})
it('judges an arrow after a chevron page against the page target', () => {
renderRow(vi.fn(), viewsOf(), 'v1')
act(() => void vi.advanceTimersByTime(OPENING_MS + 1))
stubGeometry(900, 300, () => scrolled)
act(() => chip('Vue 1').focus())
fireEvent.click(screen.getByTitle('Vues suivantes'))
expect(scrollTo).toHaveBeenLastCalledWith({ left: 240, behavior: 'smooth' })
// Instantaneously at 0 the second chip is clear; at the page target 240 it is not.
fireEvent.keyDown(chip('Vue 1'), { key: 'ArrowRight' })
expect(scrollTo).toHaveBeenLastCalledWith({ left: 28, behavior: 'smooth' })
})
})
describe('the reveal of a chip focused from outside the row', () => { describe('the reveal of a chip focused from outside the row', () => {
let scrollTo: ReturnType<typeof vi.fn> let scrollTo: ReturnType<typeof vi.fn>
beforeEach(() => { beforeEach(() => {