import { useCallback, useEffect, useState, type FocusEvent, type PointerEvent, } from 'react' import type { Geometry } from '@faunosteo/core-wasm/types' import { useEditorStore } from '../state/editorStore' /** A6/A14: how long a message stays (R-2) and how long a hint does (R-1). */ const MESSAGE_MS = 6_000 const HINT_MS = 4_000 /** The document and the history a message was shown on: any change closes it (R-2). */ interface Stamp { text: string undo: number redo: number } export interface GestureMessage { text: string tone: 'info' | 'error' /** Offers « Défaire » (a kept gesture); never on a refusal. */ undo: boolean hint: boolean stamp: Stamp /** The place the core refused, drawn in red dashes while the refusal shows. */ place: Geometry | null } export interface ShowOptions { undo: boolean tone: GestureMessage['tone'] place?: Geometry } function currentStamp(): Stamp { const { documentText, undo, redo } = useEditorStore.getState() return { text: documentText, undo: undo.length, redo: redo.length } } const sameStamp = (a: Stamp, b: Stamp) => a.text === b.text && a.undo === b.undo && a.redo === b.redo /** * Any change of the document or of either history stack closes the shown message for * good: an undo then a redo restores the same stamp, which must not bring it back (R-2). */ function useCloseOnChange(close: (now: Stamp) => void): void { useEffect( () => useEditorStore.subscribe((state, before) => { const changed = state.documentText !== before.documentText || state.undo.length !== before.undo.length || state.redo.length !== before.redo.length if (changed) close(currentStamp()) }), [close], ) } /** * Hover with a mouse and focus inside hold the message; a touch never does (R-2). The hold * belongs to the message it was taken on: a message that closes (« Défaire » pressed, the * pill unmounted without pointerleave or blur) leaves no hold on the next one. */ function useHold(message: GestureMessage | null) { const [hovered, setHovered] = useState(null) const [focused, setFocused] = useState(null) const handlers = { onPointerEnter: (event: PointerEvent) => { if (event.pointerType === 'mouse') setHovered(message) }, onPointerLeave: () => setHovered(null), onFocus: () => setFocused(message), onBlur: (event: FocusEvent) => { if (!event.currentTarget.contains(event.relatedTarget as Node | null)) { setFocused(null) } }, } const held = message !== null && (hovered === message || focused === message) return { held, handlers } } /** * The line under the drawing (A14, R-2): « Point déplacé · Défaire » after a gesture, a * refusal in red, or a hint while nothing else is shown. A message lasts 6 s, held while a * mouse hovers it or the focus is inside; any commit, undo or redo closes it. */ export function useGestureMessage() { const [message, setShown] = useState(null) const { held, handlers } = useHold(message) // A message shown after its own commit carries that commit's stamp: it stays. const close = useCallback( (now: Stamp) => setShown((shown) => shown && sameStamp(shown.stamp, now) ? shown : null, ), [], ) useCloseOnChange(close) useEffect(() => { if (!message || held) return const timer = setTimeout( () => setShown(null), message.hint ? HINT_MS : MESSAGE_MS, ) return () => clearTimeout(timer) }, [message, held]) const show = (text: string, { undo, tone, place }: ShowOptions) => setShown({ text, tone, undo, hint: false, stamp: currentStamp(), place: place ?? null, }) const hint = (text: string) => { if (message) return setShown({ text, tone: 'info', undo: false, hint: true, stamp: currentStamp(), place: null, }) } return { message, show, hint, hold: handlers } } export type GestureMessages = ReturnType