fix(editor): bubble clears the strip's commands, announces through a steady region
This commit is contained in:
1 parent
49f0144729
commit
a9252375e1
7 files changed
+313
-56
No files matched your search
@@ -54,27 +54,49 @@ const tool = (page: Page, id: string) =>
|
||||
const scrollWidth = (page: Page) =>
|
||||
page.evaluate(() => document.documentElement.scrollWidth)
|
||||
|
||||
/** The bubble sits in the window, under the top bar, under its button and clear of the other. */
|
||||
const intersects = (a: Box, b: Box) =>
|
||||
a.x < b.x + b.width &&
|
||||
b.x < a.x + a.width &&
|
||||
a.y < b.y + b.height &&
|
||||
b.y < a.y + a.height
|
||||
|
||||
interface Box {
|
||||
x: number
|
||||
y: number
|
||||
width: number
|
||||
height: number
|
||||
}
|
||||
|
||||
/**
|
||||
* The bubble sits in the window, under the top bar, right under its button (within 8 px
|
||||
* unless the bar pushes it down), and over neither « Défaire » nor the strip's commands.
|
||||
*/
|
||||
async function expectBubbleBeside(
|
||||
page: Page,
|
||||
bubble: Locator,
|
||||
button: Locator,
|
||||
other: Locator,
|
||||
) {
|
||||
const box = await bubble.boundingBox()
|
||||
const own = await button.boundingBox()
|
||||
const next = await other.boundingBox()
|
||||
const bar = await page.locator('header').first().boundingBox()
|
||||
const boxes = await Promise.all([
|
||||
bubble.boundingBox(),
|
||||
button.boundingBox(),
|
||||
other.boundingBox(),
|
||||
page.locator('header').first().boundingBox(),
|
||||
page.locator('[data-testid="edit-strip"] > :last-child').boundingBox(),
|
||||
])
|
||||
const view = page.viewportSize()
|
||||
if (!box || !own || !next || !bar || !view)
|
||||
const [box, own, next, bar, commands] = boxes
|
||||
if (!box || !own || !next || !bar || !commands || !view)
|
||||
throw new Error('a box is missing')
|
||||
expect(box.x).toBeGreaterThanOrEqual(0)
|
||||
expect(box.x + box.width).toBeLessThanOrEqual(view.width)
|
||||
expect(box.y + box.height).toBeLessThanOrEqual(view.height)
|
||||
expect(box.y).toBeGreaterThanOrEqual(bar.y + bar.height)
|
||||
expect(box.y).toBeGreaterThanOrEqual(own.y + own.height)
|
||||
const apart = box.y >= next.y + next.height || box.x >= next.x + next.width
|
||||
expect(apart).toBe(true)
|
||||
expect(box.y - (own.y + own.height)).toBeLessThanOrEqual(8)
|
||||
expect(box.width).toBeLessThanOrEqual(288)
|
||||
expect(intersects(box, next)).toBe(false)
|
||||
expect(intersects(box, commands)).toBe(false)
|
||||
}
|
||||
|
||||
interface Names {
|
||||
@@ -288,6 +310,8 @@ test.describe('editor annotations (A3)', () => {
|
||||
// The resize's own reflow (a breakpoint) settles before the press is measured.
|
||||
await page.waitForTimeout(300)
|
||||
await redo.evaluate((el) => el.scrollIntoView({ block: 'center' }))
|
||||
// Its scroll event lands before the press, which a scroll would close.
|
||||
await page.waitForTimeout(150)
|
||||
const widthBefore = await scrollWidth(page)
|
||||
await expectNoShift(page, async () => {
|
||||
await pressAtBox(page, redo)
|
||||
@@ -298,6 +322,17 @@ test.describe('editor annotations (A3)', () => {
|
||||
await expectAccessible(page, `the bubble open at ${width}`)
|
||||
await expectNoShift(page, () => page.keyboard.press('Escape'))
|
||||
await expect(bubble).toHaveCount(0)
|
||||
// Scrolled, the strip stuck under the bar: the keyboard press keeps the same rules.
|
||||
await page.evaluate(() => window.scrollTo(0, 150))
|
||||
await redo.focus()
|
||||
await page.waitForTimeout(150)
|
||||
await page.keyboard.press('Enter')
|
||||
await expect(bubble).toHaveText(reason)
|
||||
await expectBubbleBeside(page, bubble, redo, undo)
|
||||
await page.keyboard.press('Escape')
|
||||
await expect(bubble).toHaveCount(0)
|
||||
await page.evaluate(() => window.scrollTo(0, 0))
|
||||
await page.waitForTimeout(150)
|
||||
}
|
||||
await expect(page.getByTestId('gesture-message')).toHaveCount(0)
|
||||
// Escape order: the bubble first, alone; the next Escape asks about the creation.
|
||||
|
||||
@@ -11,38 +11,50 @@ interface Place {
|
||||
maxWidth: number
|
||||
}
|
||||
|
||||
/** Left edge of the annotations strip's command box while the strip is on screen. */
|
||||
function stripCommandsLeft(): number | null {
|
||||
for (const strip of document.querySelectorAll('[data-testid="edit-strip"]')) {
|
||||
const commands = strip.lastElementChild?.getBoundingClientRect()
|
||||
if (strip.getBoundingClientRect().width > 0 && commands)
|
||||
return commands.left
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
/**
|
||||
* Under the button, its right edge on the button's, never past the window's edges. Read
|
||||
* from the button's box on every scroll and resize so the bubble follows it.
|
||||
* Under the button, its right edge on the button's, never past the window's edges. With the
|
||||
* strip on screen the bubble ends left of the strip's commands, which its text may name
|
||||
* (« Annuler le tracé », « Abandonner »): it lies over the strip's notice, never over them.
|
||||
*/
|
||||
function placeUnder(anchor: HTMLElement): Place {
|
||||
const box = anchor.getBoundingClientRect()
|
||||
const width = document.documentElement.clientWidth
|
||||
const right = Math.max(EDGE, width - box.right)
|
||||
const commands = stripCommandsLeft()
|
||||
const edge =
|
||||
commands === null ? box.right : Math.min(box.right, commands - GAP)
|
||||
const right = Math.max(EDGE, width - edge)
|
||||
return { top: box.bottom + GAP, right, maxWidth: width - right - EDGE }
|
||||
}
|
||||
|
||||
/** Measured once at open and on a resize; a scroll closes the bubble instead. */
|
||||
function usePlace(anchor: HTMLElement | null): Place | null {
|
||||
const [place, setPlace] = useState<Place | null>(null)
|
||||
useLayoutEffect(() => {
|
||||
if (!anchor) return
|
||||
const measure = () => setPlace(placeUnder(anchor))
|
||||
measure()
|
||||
window.addEventListener('scroll', measure, true)
|
||||
window.addEventListener('resize', measure)
|
||||
return () => {
|
||||
window.removeEventListener('scroll', measure, true)
|
||||
window.removeEventListener('resize', measure)
|
||||
}
|
||||
return () => window.removeEventListener('resize', measure)
|
||||
}, [anchor])
|
||||
return place
|
||||
}
|
||||
|
||||
/**
|
||||
* The reason a held « Défaire » / « Refaire » gives, in a small bubble under its button. Out
|
||||
* of the flow (a portal to the body, `fixed`), so nothing of the page moves; z-20 puts it
|
||||
* over the sticky strip and the pinned drawing column and under the top bar (z-30, and the bubble never goes up past it) and the
|
||||
* modal dialogs (top layer). It never takes a press: one beside it works as usual.
|
||||
* The reason a held « Défaire » / « Refaire » gives, in a small bubble under its button.
|
||||
* Out of the flow (a portal to the body, `fixed`), so nothing of the page moves. z-20 puts
|
||||
* it over the sticky strip and the pinned drawing column, under the top bar (z-30), which
|
||||
* it never rises past, and under the modal dialogs (top layer). It takes no press. Hidden
|
||||
* from assistive technology: the button's always-mounted status region announces the text.
|
||||
*/
|
||||
export default function HeldReasonBubble({
|
||||
anchor,
|
||||
@@ -55,14 +67,14 @@ export default function HeldReasonBubble({
|
||||
if (!place) return null
|
||||
return createPortal(
|
||||
<div
|
||||
role="status"
|
||||
aria-hidden="true"
|
||||
data-testid="history-hold-bubble"
|
||||
className="pointer-events-none fixed top-[max(var(--bubble-top),calc(var(--shell-top-bar-height)+4px))] z-20 w-max rounded-md border border-[var(--color-border)] bg-[var(--color-surface)] px-3 py-2 text-sm text-[var(--color-ink)] shadow-lg"
|
||||
style={
|
||||
{
|
||||
'--bubble-top': `${place.top}px`,
|
||||
right: place.right,
|
||||
maxWidth: `min(22rem, ${place.maxWidth}px)`,
|
||||
maxWidth: `min(18rem, ${place.maxWidth}px)`,
|
||||
} as CSSProperties
|
||||
}
|
||||
>
|
||||
|
||||
@@ -151,6 +151,27 @@ function usePress(
|
||||
}
|
||||
}
|
||||
|
||||
/** What a button reads and holds: its reason, its bubble, its press handlers. */
|
||||
function useHistoryButton(
|
||||
direction: Direction,
|
||||
tab: string,
|
||||
left: RefObject<HTMLElement | null>,
|
||||
) {
|
||||
const readOnly = useEditorReadOnly()
|
||||
const steppable = useEditorStore(direction === 'undo' ? canUndo : canRedo)
|
||||
const hold = useAnnotationWork((s) => holdOf(direction, s, steppable))
|
||||
const button = useRef<HTMLButtonElement>(null)
|
||||
const bubble = useHeldBubble(hold !== null, tab, button)
|
||||
return {
|
||||
hold,
|
||||
button,
|
||||
bubble,
|
||||
press: usePress(direction, readOnly, left, bubble),
|
||||
disabled: readOnly || !steppable || hold !== null,
|
||||
reasonId: `history-hold-${direction}`,
|
||||
}
|
||||
}
|
||||
|
||||
function HistoryButton({
|
||||
direction,
|
||||
tab,
|
||||
@@ -161,25 +182,20 @@ function HistoryButton({
|
||||
left: RefObject<HTMLElement | null>
|
||||
}) {
|
||||
const t = useT()
|
||||
const readOnly = useEditorReadOnly()
|
||||
const steppable = useEditorStore(direction === 'undo' ? canUndo : canRedo)
|
||||
const hold = useAnnotationWork((s) => holdOf(direction, s, steppable))
|
||||
const h = useHistoryButton(direction, tab, left)
|
||||
const name = t(`editor.history.${direction}_title`)
|
||||
const button = useRef<HTMLButtonElement>(null)
|
||||
const bubble = useHeldBubble(hold !== null, tab, button)
|
||||
const press = usePress(direction, readOnly, left, bubble)
|
||||
const reasonId = `history-hold-${direction}`
|
||||
const reason = h.hold ? t(`editor.history.hold_${h.hold}`) : ''
|
||||
return (
|
||||
<>
|
||||
<button
|
||||
ref={button}
|
||||
ref={h.button}
|
||||
type="button"
|
||||
aria-label={name}
|
||||
title={`${name} (${t(`editor.history.${direction}_shortcut`)})`}
|
||||
aria-disabled={readOnly || !steppable || hold !== null}
|
||||
aria-describedby={hold ? reasonId : undefined}
|
||||
aria-disabled={h.disabled}
|
||||
aria-describedby={h.hold ? h.reasonId : undefined}
|
||||
aria-keyshortcuts={SHORTCUT[direction]}
|
||||
{...press}
|
||||
{...h.press}
|
||||
className={BUTTON}
|
||||
>
|
||||
<EditorGlyph name={direction} />
|
||||
@@ -187,16 +203,24 @@ function HistoryButton({
|
||||
{t(`editor.history.${direction}`)}
|
||||
</span>
|
||||
</button>
|
||||
{hold && (
|
||||
<span id={reasonId} className="sr-only">
|
||||
{t(`editor.history.hold_${hold}`)}
|
||||
{h.hold && (
|
||||
<span id={h.reasonId} className="sr-only">
|
||||
{reason}
|
||||
</span>
|
||||
)}
|
||||
{hold && bubble.open && (
|
||||
{/* Always mounted, so a press's text is announced; the keyed child says it again. */}
|
||||
<span
|
||||
role="status"
|
||||
data-testid={`history-status-${direction}`}
|
||||
className="sr-only"
|
||||
>
|
||||
{h.bubble.open && <span key={h.bubble.serial}>{reason}</span>}
|
||||
</span>
|
||||
{h.bubble.open && (
|
||||
<HeldReasonBubble
|
||||
key={bubble.serial}
|
||||
anchor={button.current}
|
||||
text={t(`editor.history.hold_${hold}`)}
|
||||
key={h.bubble.serial}
|
||||
anchor={h.button.current}
|
||||
text={reason}
|
||||
/>
|
||||
)}
|
||||
</>
|
||||
@@ -205,8 +229,8 @@ function HistoryButton({
|
||||
|
||||
/**
|
||||
* « Défaire » and « Refaire », at the right of the tab row on every tab. A press on a held
|
||||
* one says why in a bubble (announced once, by its status role: the description is read on
|
||||
* focus only); `tab` closes it when the tab changes.
|
||||
* one says why in a bubble (announced once, by the button's always-mounted status region:
|
||||
* the description is read on focus only); `tab` closes it when the tab changes.
|
||||
*/
|
||||
export default function HistoryButtons({ tab }: { tab: string }) {
|
||||
const left = useRef<HTMLElement | null>(null)
|
||||
|
||||
@@ -1,11 +1,13 @@
|
||||
import { useCallback, useEffect, useState, type RefObject } from 'react'
|
||||
import { isTextField } from '@/editor/focusRequest'
|
||||
|
||||
/**
|
||||
* A pressed-held button's bubble: open until the hold ends, the tab changes, the focus
|
||||
* leaves the button, a press lands elsewhere or Escape is pressed. The serial makes a
|
||||
* repeated press a new bubble, announced again. Escape is taken first, on the capture
|
||||
* phase, so the next one reaches what it reached before (a creation asks, pending work
|
||||
* drops); a modal dialog keeps its own.
|
||||
* leaves the button, a press lands elsewhere, the page scrolls, a dialog opens or Escape is
|
||||
* pressed. The serial makes a repeated press a new announcement. Escape is taken first, on
|
||||
* the capture phase, so the next one reaches what it reached before (a creation asks,
|
||||
* pending work drops); typed in a field it only closes the bubble, and a modal dialog keeps
|
||||
* its own.
|
||||
*/
|
||||
export function useHeldBubble(
|
||||
held: boolean,
|
||||
@@ -20,24 +22,50 @@ export function useHeldBubble(
|
||||
if (!held) close()
|
||||
}, [held, close])
|
||||
useEffect(() => close(), [tab, close])
|
||||
useDismissal(open, close, button)
|
||||
return { open, serial, show, close }
|
||||
}
|
||||
|
||||
function useDismissal(
|
||||
open: boolean,
|
||||
close: () => void,
|
||||
button: RefObject<HTMLElement | null>,
|
||||
) {
|
||||
useEffect(() => {
|
||||
if (!open) return
|
||||
const onKey = (event: KeyboardEvent) => {
|
||||
if (event.key !== 'Escape' || event.isComposing) return
|
||||
if (document.querySelector('dialog[open]')) return
|
||||
close()
|
||||
if (isTextField(event.target)) return
|
||||
event.preventDefault()
|
||||
event.stopPropagation()
|
||||
close()
|
||||
}
|
||||
const onPress = (event: Event) => {
|
||||
if (!button.current?.contains(event.target as Node)) close()
|
||||
}
|
||||
const onDialog = () => {
|
||||
if (document.querySelector('dialog[open]')) close()
|
||||
}
|
||||
const watch = new MutationObserver(onDialog)
|
||||
watch.observe(document.body, {
|
||||
subtree: true,
|
||||
attributes: true,
|
||||
attributeFilter: ['open'],
|
||||
})
|
||||
const passive = { capture: true, passive: true }
|
||||
document.addEventListener('keydown', onKey, true)
|
||||
document.addEventListener('pointerdown', onPress, true)
|
||||
for (const type of ['scroll', 'wheel', 'touchmove']) {
|
||||
document.addEventListener(type, close, passive)
|
||||
}
|
||||
return () => {
|
||||
watch.disconnect()
|
||||
document.removeEventListener('keydown', onKey, true)
|
||||
document.removeEventListener('pointerdown', onPress, true)
|
||||
for (const type of ['scroll', 'wheel', 'touchmove']) {
|
||||
document.removeEventListener(type, close, passive)
|
||||
}
|
||||
}
|
||||
}, [open, close, button])
|
||||
return { open, serial, show, close }
|
||||
}
|
||||
@@ -0,0 +1,121 @@
|
||||
/** The held-reason bubble (D1): its closing rules and its place, apart from the editor. */
|
||||
import { afterEach, describe, expect, it } from 'vitest'
|
||||
import { act, cleanup, render, renderHook, screen } from '@testing-library/react'
|
||||
import HeldReasonBubble from '@/components/editor/HeldReasonBubble'
|
||||
import { useHeldBubble } from '@/components/editor/useHeldBubble'
|
||||
|
||||
afterEach(() => {
|
||||
cleanup()
|
||||
document.body.innerHTML = ''
|
||||
})
|
||||
|
||||
function opened(tab = 'annotations') {
|
||||
const button = document.createElement('button')
|
||||
document.body.append(button)
|
||||
const ref = { current: button }
|
||||
const hook = renderHook(
|
||||
({ held, tab }) => useHeldBubble(held, tab, ref),
|
||||
{ initialProps: { held: true, tab } },
|
||||
)
|
||||
act(() => hook.result.current.show())
|
||||
expect(hook.result.current.open).toBe(true)
|
||||
return { hook, button }
|
||||
}
|
||||
|
||||
const key = (target: EventTarget, init: KeyboardEventInit = {}) => {
|
||||
const event = new KeyboardEvent('keydown', {
|
||||
key: 'Escape',
|
||||
bubbles: true,
|
||||
cancelable: true,
|
||||
...init,
|
||||
})
|
||||
act(() => {
|
||||
target.dispatchEvent(event)
|
||||
})
|
||||
return event
|
||||
}
|
||||
|
||||
describe('closing', () => {
|
||||
it('closes when the tab prop changes, with no press or focus move', () => {
|
||||
const { hook } = opened()
|
||||
hook.rerender({ held: true, tab: 'general' })
|
||||
expect(hook.result.current.open).toBe(false)
|
||||
})
|
||||
|
||||
for (const type of ['scroll', 'wheel', 'touchmove']) {
|
||||
it(`closes on ${type}`, () => {
|
||||
const { hook } = opened()
|
||||
act(() => {
|
||||
document.dispatchEvent(new Event(type, { bubbles: true }))
|
||||
})
|
||||
expect(hook.result.current.open).toBe(false)
|
||||
})
|
||||
}
|
||||
|
||||
it('closes when a dialog opens', async () => {
|
||||
const { hook } = opened()
|
||||
const dialog = document.createElement('dialog')
|
||||
document.body.append(dialog)
|
||||
await act(async () => {
|
||||
dialog.setAttribute('open', '')
|
||||
await Promise.resolve()
|
||||
})
|
||||
expect(hook.result.current.open).toBe(false)
|
||||
})
|
||||
|
||||
it('Escape closes it and is taken from everything else', () => {
|
||||
const { hook, button } = opened()
|
||||
const event = key(button)
|
||||
expect(hook.result.current.open).toBe(false)
|
||||
expect(event.defaultPrevented).toBe(true)
|
||||
expect(key(button).defaultPrevented).toBe(false)
|
||||
})
|
||||
|
||||
it('Escape typed in a text field closes it and stays the field\'s', () => {
|
||||
const { hook } = opened()
|
||||
const field = document.createElement('input')
|
||||
document.body.append(field)
|
||||
const event = key(field)
|
||||
expect(hook.result.current.open).toBe(false)
|
||||
expect(event.defaultPrevented).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
describe('the place', () => {
|
||||
const rect = (left: number, right: number, top = 0, bottom = 40) =>
|
||||
({ left, right, top, bottom, width: right - left, height: bottom - top }) as DOMRect
|
||||
function anchor() {
|
||||
const button = document.createElement('button')
|
||||
document.body.append(button)
|
||||
button.getBoundingClientRect = () => rect(900, 960, 10, 50)
|
||||
Object.defineProperty(document.documentElement, 'clientWidth', {
|
||||
configurable: true,
|
||||
value: 1024,
|
||||
})
|
||||
return button
|
||||
}
|
||||
const strip = (commandsLeft: number) => {
|
||||
const el = document.createElement('div')
|
||||
el.dataset.testid = 'edit-strip'
|
||||
const commands = document.createElement('div')
|
||||
el.append(commands)
|
||||
el.getBoundingClientRect = () => rect(100, 980, 70, 134)
|
||||
commands.getBoundingClientRect = () => rect(commandsLeft, 970, 74, 130)
|
||||
document.body.append(el)
|
||||
}
|
||||
|
||||
it('sits 4 px under its button, right edge on the button, without a strip', () => {
|
||||
render(<HeldReasonBubble anchor={anchor()} text="why" />)
|
||||
const bubble = screen.getByTestId('history-hold-bubble')
|
||||
expect(bubble.style.getPropertyValue('--bubble-top')).toBe('54px')
|
||||
expect(bubble.style.right).toBe('64px')
|
||||
expect(bubble.style.maxWidth).toBe('min(18rem, 952px)')
|
||||
})
|
||||
|
||||
it('ends left of the strip\'s commands when the strip is shown', () => {
|
||||
strip(760)
|
||||
render(<HeldReasonBubble anchor={anchor()} text="why" />)
|
||||
const bubble = screen.getByTestId('history-hold-bubble')
|
||||
expect(bubble.style.right).toBe('268px')
|
||||
})
|
||||
})
|
||||
@@ -790,10 +790,44 @@ describe('why a button is held (point 6)', () => {
|
||||
stacks()
|
||||
pend()
|
||||
await user.click(redoButton())
|
||||
expect(bubble()).toHaveAttribute('role', 'status')
|
||||
expect(bubble()).toHaveAttribute('aria-hidden', 'true')
|
||||
return user
|
||||
}
|
||||
|
||||
it('is announced by the button\'s always-mounted status region, once per press', async () => {
|
||||
const user = await openAnnotations()
|
||||
stacks()
|
||||
pend()
|
||||
const region = screen.getByTestId('history-status-redo')
|
||||
expect(region).toHaveAttribute('role', 'status')
|
||||
expect(region).toBeEmptyDOMElement()
|
||||
await user.click(redoButton())
|
||||
expect(region).toBe(screen.getByTestId('history-status-redo'))
|
||||
expect(region).toHaveTextContent(PENDING)
|
||||
const first = region.firstElementChild
|
||||
await user.click(redoButton())
|
||||
expect(region).toHaveTextContent(PENDING)
|
||||
expect(region.children).toHaveLength(1)
|
||||
expect(region.firstElementChild).not.toBe(first)
|
||||
await user.pointer({ keys: '[MouseLeft]', target: document.body })
|
||||
expect(region).toBeEmptyDOMElement()
|
||||
})
|
||||
|
||||
it('a second Escape drops the pending work, as before', async () => {
|
||||
const user = await openAnnotations()
|
||||
const list = screen.getByRole('list', { name: 'Annotations de la vue' })
|
||||
await user.click(within(list).getAllByRole('button')[0]!)
|
||||
stacks()
|
||||
pend()
|
||||
redoButton().focus()
|
||||
await user.keyboard('{Enter}')
|
||||
await user.keyboard('{Escape}')
|
||||
noMessage()
|
||||
expect(useAnnotationWork.getState().preview).not.toBeNull()
|
||||
await user.keyboard('{Escape}')
|
||||
expect(useAnnotationWork.getState().preview).toBeNull()
|
||||
})
|
||||
|
||||
it('is portalled out of the row, so nothing in the layout can move', async () => {
|
||||
await heldRedo()
|
||||
expect(screen.getByTestId('history-buttons')).not.toContainElement(
|
||||
@@ -860,7 +894,7 @@ describe('why a button is held (point 6)', () => {
|
||||
expect(bubble()).toHaveTextContent(PENDING)
|
||||
expect(bubble().style.getPropertyValue('--bubble-top')).toBe('54px')
|
||||
expect(bubble().style.right).toBe('64px')
|
||||
expect(bubble().style.maxWidth).toBe('min(22rem, 952px)')
|
||||
expect(bubble().style.maxWidth).toBe('min(18rem, 952px)')
|
||||
delete (document.documentElement as { clientWidth?: number }).clientWidth
|
||||
})
|
||||
})
|
||||
|
||||
@@ -277,12 +277,15 @@ its targets with the strip's height added. It excludes the strip's commands and
|
||||
dialog's controls, and the bar itself lies outside the workspace.
|
||||
|
||||
A press on a held « Défaire » or « Refaire » (D1, criterion 33) says why in a bubble under
|
||||
that button, on every tab. It is a `role="status"` element portalled to the body with
|
||||
`position: fixed` (no layout shift), at z-20: over the sticky strip and the pinned column,
|
||||
under the top bar (z-30, and it never sits higher than the bar's bottom) and the modal
|
||||
dialogs. Its right edge follows the button's, kept 8 px inside the window. It ends with the
|
||||
hold, a tab change, the focus leaving the button, a press elsewhere, or Escape, which it
|
||||
takes before any other Escape.
|
||||
that button, on every tab. It is portalled to the body with `position: fixed` (no layout
|
||||
shift), at z-20: over the sticky strip and the pinned column, under the top bar (z-30, and it
|
||||
never sits higher than the bar's bottom) and the modal dialogs. At most 18 rem wide, its
|
||||
right edge follows the button's, kept 8 px inside the window; while the strip is on screen
|
||||
it ends 4 px left of the strip's command box, so the commands its text names stay visible.
|
||||
It is `aria-hidden`: each button carries an always-mounted visually hidden `role="status"`
|
||||
region whose keyed child holds the text per press. It ends with the hold, a tab change, the
|
||||
focus leaving the button, a press elsewhere, a scroll, a dialog opening, or Escape, which it
|
||||
takes before any other Escape (typed in a text field it only closes the bubble).
|
||||
|
||||
A creation (U2 Task 7, A2, A4, A12) is drawn by the overlay too, never by the
|
||||
core, since the new shape is not in the document until « Créer »:
|
||||
|
||||
Reference in new issue
Block a user