reference.id === view.edit) ?? null
+}
+
+/**
+ * The reference the dialog edits vanished (a reload after a conflict, a Back onto a dead
+ * entry): the layer closes by replace and says so (R2F-5). After this commit's effects,
+ * as the finding dialog's rule: a form that registered a guard in them can still be asked.
+ */
+function useGoneRule(layer: ReferenceLayer) {
+ const t = useT()
+ const doc = useSheetDocument()
+ const handled = useRef
(null)
+ const { view } = layer
+ useEffect(() => {
+ if (!view) handled.current = null
+ if (!doc || !view || !('edit' in view)) return
+ const stamp = JSON.stringify(view)
+ if (editedIn(view, doc.references) || handled.current === stamp) return
+ handled.current = stamp
+ queueMicrotask(() => layer.replace(null, t('editor.references.gone')))
+ }, [view, doc, layer, t])
+}
+
+/** Where a closed dialog returns the focus: the tile's header, or the add button. */
+function useReturnTarget(layer: ReferenceLayer) {
+ const last = useRef(layer.view)
+ if (layer.view) last.current = layer.view
+ const { opener } = layer
+ return useCallback((): HTMLElement | null => {
+ const shown = last.current
+ if (!shown) return null
+ if ('create' in shown) return document.getElementById(ADD_BUTTON_ID)
+ const wanted = JSON.stringify({ kind: 'reference', id: shown.edit })
+ return (
+ opener() ??
+ visibleElement('[data-tile-header]', (element) => {
+ return element.dataset.focusKey === wanted
+ })
+ )
+ }, [opener])
+}
+
+/** What the layer shows: a creation, or the reference it edits (null once it is gone). */
+function useShownReference(layer: ReferenceLayer) {
+ const t = useT()
+ const doc = useSheetDocument()
+ const creating = !!layer.view && 'create' in layer.view
+ const edited = editedIn(layer.view, doc?.references)
+ const title = creating
+ ? 'editor.reference.new'
+ : 'editor.references.edit_title'
+ return { creating, edited, title: t(title), open: creating || !!edited }
+}
+
+/** What a save does: a creation is announced, then handed over; an edit closes the layer. */
+function useOnSaved(layer: ReferenceLayer, creating: boolean) {
+ const t = useT()
+ return (id: string, citation: string) => {
+ if (!creating) return void layer.close(true)
+ layer.announce(t('editor.references.added').replace('{citation}', citation))
+ layer.created(id)
+ }
+}
+
+/**
+ * The reference dialog (R2F-5): one `Dialog` over the References tab or the citations
+ * sheet, a form for a reference's type, DOI, citation and URL, or for a new one. The view
+ * layer of the browser history drives it; it is no part of a kept place, so it is never a
+ * native modal inside a hidden one.
+ */
+export default function ReferenceDialog({
+ layer,
+ readOnly,
+}: ReferenceDialogProps) {
+ const shown = useShownReference(layer)
+ const returnFocus = useReturnTarget(layer)
+ const onSaved = useOnSaved(layer, shown.creating)
+ useGoneRule(layer)
+ return (
+ (layer.close() ? undefined : 'kept')}
+ >
+ layer.close(forced)}
+ />
+
+ )
+}
diff --git a/apps/app/src/components/editor/references/ReferenceEditor.tsx b/apps/app/src/components/editor/references/ReferenceEditor.tsx
deleted file mode 100644
index 8716b6c1..00000000
--- a/apps/app/src/components/editor/references/ReferenceEditor.tsx
+++ /dev/null
@@ -1,61 +0,0 @@
-import type { Reference, ReferenceType } from '@faunosteo/core-wasm/types'
-import DraftField from '@/components/editor/fields/DraftField'
-import SelectField from '@/components/editor/fields/SelectField'
-import { useT } from '@/i18n/useT'
-import { REFERENCE_TYPES } from './referenceTypes'
-import {
- useReferenceEdit,
- type EditHooks,
- type Field,
-} from './useReferenceEdit'
-
-interface Props {
- reference: Reference
- /** DOM id prefix of the tile (host, position and id): the fields' ids derive from it. */
- base: string
- /** The tile's leave guard (registered while mounted), focus ticket and dropped-draft slot. */
- hooks: EditHooks
-}
-
-/** The edit view of one reference (board 24 D): type, DOI, citation and URL. */
-export default function ReferenceEditor(props: Props) {
- const { reference, base } = props
- const t = useT()
- const { edit, drafts, setDraft, commitField, setType } = useReferenceEdit(
- reference,
- base,
- props.hooks,
- )
- const text = (field: Field, label: string, multiline = false) => (
- setDraft(field, value)}
- onBlur={() => commitField(field)}
- multiline={multiline}
- error={edit.fieldError(field)}
- />
- )
- const options = REFERENCE_TYPES.map((type) => ({
- value: type,
- label: t(`editor.reference.type.${type}`),
- }))
- return (
-
-
- setType(type as ReferenceType)}
- error={edit.fieldError('type')}
- />
- {text('doi', t('editor.reference.doi'))}
-
- {text('citation', t('editor.reference.citation'), true)}
- {text('url', t('editor.reference.url'))}
-
- )
-}
diff --git a/apps/app/src/components/editor/references/ReferenceForm.tsx b/apps/app/src/components/editor/references/ReferenceForm.tsx
new file mode 100644
index 00000000..36a262a1
--- /dev/null
+++ b/apps/app/src/components/editor/references/ReferenceForm.tsx
@@ -0,0 +1,246 @@
+import { useRef } from 'react'
+import type {
+ EditCommand,
+ Reference,
+ ReferenceType,
+} from '@faunosteo/core-wasm/types'
+import DraftField from '@/components/editor/fields/DraftField'
+import SelectField from '@/components/editor/fields/SelectField'
+import { FormActions } from '@/components/editor/findings/DiscardConfirm'
+import ReadOnlyNotice from '@/components/editor/findings/ReadOnlyNotice'
+import { useFormDraft } from '@/components/editor/findings/useDirtyGuard'
+import { webHref } from '@/editor/references/safeLink'
+import { isBlank, nullable } from '@/editor/sheetDocument'
+import { useEditCommand } from '@/editor/useEditCommand'
+import type { Guards } from '@/editor/useEditorNavigation'
+import { useT } from '@/i18n/useT'
+import { REFERENCE_TYPES } from './referenceTypes'
+
+/** What the form edits, as plain strings: nothing is written before « Enregistrer ». */
+interface Draft {
+ type: string
+ citation: string
+ doi: string
+ url: string
+}
+
+const EMPTY: Draft = { type: '', citation: '', doi: '', url: '' }
+
+const draftOf = (reference: Reference): Draft => ({
+ type: reference.type,
+ citation: reference.citation,
+ doi: reference.doi ?? '',
+ url: reference.url ?? '',
+})
+
+/** The draft as the document would hold it: a blank optional field is absent. */
+const normalized = (draft: Draft): Draft => ({
+ ...draft,
+ doi: nullable(draft.doi) ?? '',
+ url: nullable(draft.url) ?? '',
+})
+
+const sameDraft = (a: Draft, b: Draft) =>
+ JSON.stringify(normalized(a)) === JSON.stringify(normalized(b))
+
+type Field = 'type' | 'citation' | 'url'
+
+/** The first field the core would refuse, with the words for it; null when none. */
+function refusalOf(
+ draft: Draft,
+ creating: boolean,
+): { field: Field; key: string } | null {
+ const required = 'editor.field.required'
+ if (creating && draft.type === '') return { field: 'type', key: required }
+ if (isBlank(draft.citation)) return { field: 'citation', key: required }
+ const url = nullable(draft.url)
+ if (url !== null && webHref(url) === null) {
+ return { field: 'url', key: 'editor.reference.url_invalid' }
+ }
+ return null
+}
+
+/** The reference the draft makes under `id`. */
+function valueOf(draft: Draft, id: string): Reference {
+ const now = normalized(draft)
+ return {
+ id,
+ type: now.type as ReferenceType,
+ citation: now.citation,
+ doi: nullable(now.doi),
+ url: nullable(now.url),
+ }
+}
+
+export interface ReferenceFormProps {
+ /** The reference edited; null for a creation. */
+ reference: Reference | null
+ readOnly: boolean
+ guards: Guards
+ /** One command was written; `id` and `citation` are the reference's. */
+ onSaved: (id: string, citation: string) => void
+ /** Nothing was written (pristine save, « Annuler », « Abandonner »); forced drops a draft. */
+ onClose: (forced: boolean) => void
+}
+
+type Form = ReturnType>
+
+/**
+ * The one command of a save: an `update` of the reference, or an `insert` under a new id.
+ * The dialog closes after a save: a second submit while it plays its exit writes nothing.
+ */
+function useWrite(reference: Reference | null, draft: Draft) {
+ const edit = useEditCommand()
+ const saved = useRef(false)
+ const run = (): string | null => {
+ if (reference) {
+ const element = { kind: 'reference', value: valueOf(draft, reference.id) }
+ const key = { kind: 'reference', id: reference.id }
+ const command = { op: 'update', key, element } as EditCommand
+ return edit.run('form', command) ? reference.id : null
+ }
+ let id = ''
+ const added = edit.runNew('form', 'ref', (fresh) => {
+ id = fresh
+ const element = { kind: 'reference', value: valueOf(draft, fresh) }
+ return { op: 'insert', element } as EditCommand
+ })
+ return added ? id : null
+ }
+ const write = (): string | null => {
+ const id = saved.current ? null : run()
+ saved.current = saved.current || id !== null
+ return id
+ }
+ return { edit, write }
+}
+
+/** The save: refused on its field, nothing written when unchanged, else one command. */
+function useReferenceSave(props: ReferenceFormProps, form: Form) {
+ const { edit, write } = useWrite(props.reference, form.draft)
+ const save = () => {
+ const refusal = refusalOf(form.draft, props.reference === null)
+ if (refusal) {
+ edit.reject(refusal.field, refusal.key)
+ document.getElementById(`reference-form-${refusal.field}`)?.focus()
+ return
+ }
+ if (!form.dirty) return props.onClose(false)
+ const id = write()
+ if (id !== null) props.onSaved(id, form.draft.citation)
+ }
+ return { save, edit }
+}
+
+/** The form's state: the local draft, its guard and its save. */
+function useReferenceForm(props: ReferenceFormProps) {
+ const first = props.reference ? draftOf(props.reference) : EMPTY
+ const form = useFormDraft(first, props.guards, sameDraft, 'reference')
+ return { ...form, ...useReferenceSave(props, form) }
+}
+
+type ReferenceFormState = ReturnType
+
+/** One of the three text fields of the form, a draft field with its own refusal. */
+function Text(props: {
+ form: ReferenceFormState
+ field: 'doi' | 'citation' | 'url'
+ readOnly: boolean
+ multiline?: boolean
+}) {
+ const t = useT()
+ const { form, field } = props
+ return (
+ form.set({ [field]: value })}
+ readOnly={props.readOnly}
+ multiline={props.multiline}
+ error={form.edit.fieldError(field)}
+ />
+ )
+}
+
+/** The type, then the three texts, as draft fields. */
+function FormFields({
+ form,
+ readOnly,
+}: {
+ form: ReferenceFormState
+ readOnly: boolean
+}) {
+ const t = useT()
+ const options = [
+ { value: '', label: t('editor.field.choose') },
+ ...REFERENCE_TYPES.map((type) => ({
+ value: type,
+ label: t(`editor.reference.type.${type}`),
+ })),
+ ]
+ return (
+ <>
+
+ form.set({ type })}
+ readOnly={readOnly}
+ error={form.edit.fieldError('type')}
+ />
+
+
+
+
+ >
+ )
+}
+
+/**
+ * A reference edited or created in the reference dialog (R2F-5): a local draft, one
+ * command on « Enregistrer » (none when nothing changed), nothing on « Annuler », a close
+ * or a move. When the editor turns read-only the draft stays, its fields read-only, and
+ * only « Abandonner » is left.
+ */
+export default function ReferenceForm(props: ReferenceFormProps) {
+ const t = useT()
+ const form = useReferenceForm(props)
+ const { guard } = form
+ const creating = props.reference === null
+ return (
+
+ )
+}
diff --git a/apps/app/src/components/editor/references/ReferenceTile.tsx b/apps/app/src/components/editor/references/ReferenceTile.tsx
index f2dd3dbb..5cef07c9 100644
--- a/apps/app/src/components/editor/references/ReferenceTile.tsx
+++ b/apps/app/src/components/editor/references/ReferenceTile.tsx
@@ -1,43 +1,23 @@
-import {
- useCallback,
- useContext,
- useLayoutEffect,
- useRef,
- useState,
- type RefObject,
-} from 'react'
import type { ElementKey, Reference } from '@faunosteo/core-wasm/types'
import ActionButton from '@/components/editor/fields/ActionButton'
import Icon from '@/components/ui/Icon'
-import { AnnounceContext } from '@/editor/focusRequest'
import { usePlural } from '@/editor/plural'
import type { CiterItem } from '@/editor/references/citations'
import { useT } from '@/i18n/useT'
import CitersList from './CitersList'
-import ReferenceEditor from './ReferenceEditor'
import ReferenceFacts from './ReferenceFacts'
import type { ReferenceHost } from './referenceTypes'
-import { useDroppedText, type Field, type LeaveGuard } from './useReferenceEdit'
/** What a tile asks of the library that owns its state. */
export interface TileHandlers {
toggle: () => void
- edit: () => void
- /** Leaves the edit view; false (the view stays) when a field refuses. */
- done: () => boolean
+ /** « Modifier »: opens the reference dialog; `opener` is where the focus returns. */
+ edit: (opener: HTMLElement) => void
/** « Supprimer »: the Références tab only. */
remove?: () => void
/** « Monter » / « Descendre »: the Références tab only. */
move?: (position: number) => void
goTo: (key: ElementKey) => void
- registerLeave: (guard: LeaveGuard | null) => void
- /** True once after « Modifier »: the edit view then focuses its Citation field. */
- takeFocus: () => boolean
- /**
- * True while the host itself unmounts: the leave that closed it already said the dropped
- * drafts (the citations panel's forced close), so the tile does not say them again.
- */
- hostLeaving?: () => boolean
}
/** What a tile of the citations panel adds: the finding it belongs to and « Retirer ». */
@@ -56,7 +36,6 @@ export interface TileProps {
count: number
citers: readonly CiterItem[]
open: boolean
- editing: boolean
readOnly: boolean
/** ↑ / ↓ only while neither the search nor a sort narrows or reorders the list. */
movable: boolean
@@ -82,58 +61,34 @@ const BUTTON_RING =
'focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--color-accent)]'
/** The disclosure button: citation (two lines when closed), type and how often it is cited. */
-function TileHeader({
- base,
- props,
- headerRef,
- onToggle,
-}: {
- base: string
- props: TileProps
- headerRef: RefObject
- onToggle: () => void
-}) {
+function TileHeader({ base, props }: { base: string; props: TileProps }) {
const t = useT()
const plural = usePlural()
- const { reference, open, editing, citers } = props
+ const { reference, open, citers } = props
const cited = citers.length
const key = JSON.stringify({ kind: 'reference', id: reference.id })
return (
+ {props.filter &&
props.onAdd(event.currentTarget)}
>
{t('editor.references.add')}
diff --git a/apps/app/src/components/editor/references/useCitationsPanel.ts b/apps/app/src/components/editor/references/useCitationsPanel.ts
index d6846ca9..68974a72 100644
--- a/apps/app/src/components/editor/references/useCitationsPanel.ts
+++ b/apps/app/src/components/editor/references/useCitationsPanel.ts
@@ -6,15 +6,11 @@ import { citedIds, citingFinding } from '@/editor/references/filter'
import { citationEntries, findingPath } from '@/editor/references/panel'
import { useSheetDocument } from '@/editor/sheetDocument'
import { useEditCommand } from '@/editor/useEditCommand'
-import type { Guards, LeaveAnswer } from '@/editor/useEditorNavigation'
-import { useDroppedText } from './useReferenceEdit'
import { tileKeys, useTileState } from './useTileState'
export interface PanelHooks {
readOnly: boolean
citedBy: ElementKey
- /** The layers' guards: the tile in edit registers its own for the sheet. */
- guards: Guards
}
/** The finding read from the current document; null once the document lacks it. */
@@ -27,29 +23,6 @@ function useCitedFinding(citedBy: ElementKey) {
return { doc, item }
}
-/**
- * P22'': a move that leaves the sheet asks the tile in edit first (a refusal cancels the
- * move); a forced one (the finding vanished) drops a refused draft and says so. Interim
- * until the reference dialog replaces the inline tile edit.
- */
-function useLeaveCheck(tiles: ReturnType
, guards: Guards) {
- const droppedText = useDroppedText()
- const check = (forced: boolean): LeaveAnswer => {
- const refused = tiles.leave()
- if (refused.length === 0) return { allowed: true }
- if (!forced) return { allowed: false }
- return { allowed: true, note: droppedText(refused) }
- }
- // Registered once and kept: the layers' effects of one commit run cleanups first, so a
- // guard re-registered on every render would be absent when another layer asks.
- const latest = useRef(check)
- latest.current = check
- useEffect(() => {
- guards.register('citations', (forced) => latest.current(forced))
- return () => guards.register('citations', null)
- }, [guards])
-}
-
/** The row the focus is in: its element, its index in the list and the list's length. */
interface Held {
element: Element
@@ -135,12 +108,11 @@ export function useCitationsPanel(hooks: PanelHooks) {
const edit = useEditCommand()
const tiles = useTileState(doc ? keys : null)
const focus = useFocusRescue()
- useLeaveCheck(tiles, hooks.guards)
// « Retirer de ce constat » is the detail's « Retirer »: the same update of the finding's
// reference_ids, so the core marks the finding « À confirmer » (P15) and one « Défaire »
// restores the citation and the status together. The reference itself stays in the sheet.
const remove = (at: number) => {
- if (!item || !tiles.finish()) return
+ if (!item) return
const rest = ids.filter((_, index) => index !== at)
const element = patchElement(item, { reference_ids: rest })
const command = { op: 'update', key: item.key, element } as const
diff --git a/apps/app/src/components/editor/references/useReferenceEdit.ts b/apps/app/src/components/editor/references/useReferenceEdit.ts
deleted file mode 100644
index ffe4578a..00000000
--- a/apps/app/src/components/editor/references/useReferenceEdit.ts
+++ /dev/null
@@ -1,178 +0,0 @@
-import { useEffect, useLayoutEffect, useRef, useState } from 'react'
-import type { Reference, ReferenceType } from '@faunosteo/core-wasm/types'
-import { isBlank, nullable } from '@/editor/sheetDocument'
-import { useEditCommand } from '@/editor/useEditCommand'
-import { useT } from '@/i18n/useT'
-
-/** The text fields of the edit view, in the order the leave guard tries them. */
-export const FIELDS = ['citation', 'doi', 'url'] as const
-export type Field = (typeof FIELDS)[number]
-type Drafts = Record
-
-/**
- * What the guard calls on a leave: every pending field is tried; the fields that refused
- * (their drafts stay, the first one is focused), empty when all were applied.
- */
-export type LeaveGuard = () => Field[]
-
-/** What the tile hands its edit view (the library owns the state). */
-export interface EditHooks {
- registerLeave: (guard: LeaveGuard | null) => void
- /** True once per « Modifier »: the mount focuses Citation, a remount never does. */
- takeFocus: () => boolean
- /** The view unmounted with these refused drafts; stable (it runs from a cleanup). */
- onDrop: (fields: readonly Field[]) => void
-}
-
-const committedOf = (reference: Reference): Drafts => ({
- citation: reference.citation,
- doi: reference.doi ?? '',
- url: reference.url ?? '',
-})
-
-/** The document value a draft gives (a blank optional field is null, so ''). */
-const normalized = (field: Field, draft: string) =>
- field === 'citation' ? draft : (nullable(draft) ?? '')
-
-const patched = (reference: Reference, field: Field, draft: string) =>
- field === 'citation'
- ? { ...reference, citation: draft }
- : { ...reference, [field]: nullable(draft) }
-
-/** One draft per text field; a new committed value (undo, reload) replaces its draft. */
-function useDrafts(reference: Reference) {
- const committed = committedOf(reference)
- const [drafts, setDrafts] = useState(committed)
- const [seen, setSeen] = useState(committed)
- const changed = FIELDS.filter((field) => seen[field] !== committed[field])
- if (changed.length > 0) {
- setSeen(committed)
- const fresh = changed.map((field) => [field, committed[field]])
- setDrafts({ ...drafts, ...Object.fromEntries(fresh) })
- }
- const setDraft = (field: Field, value: string) =>
- setDrafts({ ...drafts, [field]: value })
- return [drafts, setDraft] as const
-}
-
-/** The fields whose draft differs from `reference`, in `FIELDS` order. */
-const pendingFields = (reference: Reference, drafts: Drafts) =>
- FIELDS.filter(
- (field) =>
- normalized(field, drafts[field]) !== committedOf(reference)[field],
- )
-
-/**
- * The reference as the document holds it now, and the drafts as typed. A blur right after
- * an apply (« Terminer » focusing the header, a close) runs before the next render, so
- * the rendered `reference` is stale there: `applied` advances with every apply and is
- * replaced when the document hands a new reference (undo, reload) (C1).
- */
-function useAppliedReference(reference: Reference, drafts: Drafts) {
- const applied = useRef(reference)
- const typed = useRef(drafts)
- useLayoutEffect(() => {
- applied.current = reference
- }, [reference])
- useLayoutEffect(() => {
- typed.current = drafts
- })
- return { applied, typed }
-}
-
-/** What the view does to the document: `update`, `apply` a draft, which drafts are `pending`. */
-function useWriter(reference: Reference, drafts: Drafts) {
- const edit = useEditCommand()
- const { applied, typed } = useAppliedReference(reference, drafts)
- const update = (field: string, value: Reference) => {
- const key = { kind: 'reference', id: reference.id } as const
- const element = { kind: 'reference', value } as const
- const done = edit.run(field, { op: 'update', key, element })
- if (done) applied.current = value
- return done
- }
- const apply = (field: Field): boolean => {
- if (field === 'citation' && isBlank(drafts[field])) {
- return edit.reject(field, 'editor.field.required')
- }
- return update(field, patched(applied.current, field, drafts[field]))
- }
- const pending = (field: Field) =>
- normalized(field, drafts[field]) !== committedOf(applied.current)[field]
- return { edit, applied, typed, update, apply, pending }
-}
-
-/** The view's three effects: its guard, the focus ticket and the dropped-draft report. */
-function useEditLifecycle(
- base: string,
- hooks: EditHooks,
- leave: LeaveGuard,
- writer: Pick, 'applied' | 'typed'>,
-) {
- const { registerLeave, takeFocus, onDrop } = hooks
- const { applied, typed } = writer
- useEffect(() => {
- registerLeave(leave)
- return () => registerLeave(null)
- })
- useEffect(() => {
- if (takeFocus()) document.getElementById(`${base}-citation`)?.focus()
- }, [base, takeFocus])
- // Never clears a report (a StrictMode remount runs this cleanup with nothing pending).
- useLayoutEffect(
- () => () => {
- const pending = pendingFields(applied.current, typed.current)
- if (pending.length > 0) onDrop(pending)
- },
- [applied, typed, onDrop],
- )
-}
-
-/**
- * The write path of one reference's edit view. A field applies to the draft when it
- * loses the focus (`commitField`); `leave` re-applies every field whose text differs from
- * the document, focuses the first refused field and shows that field's refusal (the view
- * has one error slot; the other refused drafts stay as typed) (P22, P22', I1).
- * `base` is the DOM id prefix of the tile; `registerLeave` hands `leave` to the library.
- * `takeFocus` says whether this mount is a user's « Modifier » (it focuses Citation) and
- * `onDrop` receives the fields of the refused drafts the view is unmounted with (M1).
- */
-export function useReferenceEdit(
- reference: Reference,
- base: string,
- hooks: EditHooks,
-) {
- const [drafts, setDraft] = useDrafts(reference)
- const writer = useWriter(reference, drafts)
- const { edit, applied, apply, pending } = writer
- const leave: LeaveGuard = () => {
- const refused = FIELDS.filter(pending).filter((field) => !apply(field))
- if (refused.length === 0) return refused
- // The focus move runs the blur commit of the field that held it, which writes the
- // one error slot; re-applying the first refusal last makes the focused field the
- // one that shows its message (I1). Refused again, it writes nothing.
- document.getElementById(`${base}-${refused[0]}`)?.focus()
- apply(refused[0])
- return refused
- }
- useEditLifecycle(base, hooks, leave, writer)
- return {
- edit,
- drafts,
- setDraft,
- commitField: (field: Field) => pending(field) && apply(field),
- setType: (type: ReferenceType) =>
- writer.update('type', { ...applied.current, type }),
- }
-}
-
-/** « Saisie non appliquée : Citation, Adresse web (URL) »: the words for dropped drafts. */
-export function useDroppedText(): (fields: readonly Field[]) => string {
- const t = useT()
- return (fields) => {
- const names = fields.map((field) => t(`editor.reference.${field}`))
- return t('editor.references.draft_dropped').replace('{field}', () =>
- names.join(', '),
- )
- }
-}
diff --git a/apps/app/src/components/editor/references/useReferenceLibrary.ts b/apps/app/src/components/editor/references/useReferenceLibrary.ts
index a0d2fe40..dcc9456e 100644
--- a/apps/app/src/components/editor/references/useReferenceLibrary.ts
+++ b/apps/app/src/components/editor/references/useReferenceLibrary.ts
@@ -7,27 +7,69 @@ import {
type FocusRequest,
} from '@/editor/focusRequest'
import { citersOf } from '@/editor/references/citations'
-import { referenceMatches } from '@/editor/references/filter'
+import {
+ citedIds,
+ citingFinding,
+ referenceMatches,
+} from '@/editor/references/filter'
import { useSheetDocument } from '@/editor/sheetDocument'
+import type { ReferenceLayer } from '@/editor/tabs'
+import { useT } from '@/i18n/useT'
+import { usePlaceVisible } from '@/lib/placeVisibility'
import { tileKeys, useTileState } from './useTileState'
import { useReferenceView } from './useReferenceView'
-import { ADD_BUTTON_ID } from './addButton'
const NO_CITERS = new Map()
-/** The document's references with the tab's tile state and display order. */
-export function useReferenceLibrary(resetSignal: number) {
+/**
+ * The finding the filter names, read from the current document, with the ids it cites. A
+ * filter whose finding is gone (an undo, a reload, a Back onto a dead entry) is removed by
+ * replace and says so once (R2F-6).
+ */
+function useFilterFinding(layer: ReferenceLayer) {
+ const t = useT()
+ const doc = useSheetDocument()
+ const finding = doc ? citingFinding(doc, layer.filter) : null
+ const gone = doc !== null && layer.filter !== null && finding === null
+ useEffect(() => {
+ if (gone) layer.clearFilter(t('editor.references.filter_gone'))
+ // The wording and the move are stable per render; the vanished finding is the trigger.
+ // eslint-disable-next-line react-hooks/exhaustive-deps
+ }, [gone])
+ return { finding, cited: finding ? new Set(citedIds(finding)) : null }
+}
+
+/** The tile key of the reference the dialog edits, while this tab is the place shown. */
+function useEditedKey(layer: ReferenceLayer): string | null {
+ const shown = usePlaceVisible()
+ const { view } = layer
+ return shown && view && 'edit' in view ? `${view.edit}#0` : null
+}
+
+/** The document's references, one tile key each, the tile state and who cites what. */
+function useBibliography() {
const doc = useSheetDocument()
const all: readonly Reference[] = doc?.references ?? []
const keys = tileKeys(all)
const tiles = useTileState(doc ? keys : null)
const citers = doc ? citersOf(doc) : NO_CITERS
+ return { loaded: doc !== null, all, keys, tiles, citers }
+}
+
+/** The document's references with the tab's tile state and display order. */
+export function useReferenceLibrary(
+ resetSignal: number,
+ layer: ReferenceLayer,
+) {
+ const bibliography = useBibliography()
+ const filter = useFilterFinding(layer)
const shown = useReferenceView(
- { all, keys, citers },
- tiles.editingKey,
+ bibliography,
+ useEditedKey(layer),
resetSignal,
+ filter.cited,
)
- return { loaded: doc !== null, all, keys, tiles, citers, shown }
+ return { ...bibliography, shown, finding: filter.finding }
}
export type ReferenceLibraryState = ReturnType
@@ -45,65 +87,76 @@ function useLateFocus() {
const positionOf = (all: readonly Reference[], key: ElementKey) =>
all.findIndex((r) => key.kind === 'reference' && r.id === key.id)
+type Show = (key: ElementKey) => 'found' | 'none'
+
/**
- * « Aller à » a reference: its tile is opened, the search is cleared (only it, P3) when it
- * hides the tile, and the tile's button is focused after the commit that shows it (P8).
+ * Shows a reference's tile: opened, the search cleared (only it, P3) and the finding
+ * filter removed when they hide it, its button focused after the commit that shows it
+ * (P8). `none` when the sheet holds no such reference.
*/
-function useReferenceFocus(
- focus: FocusRequest | undefined,
+function useShowReference(
lib: ReferenceLibraryState,
- later: (key: ElementKey) => void,
-) {
- const { all, keys, tiles, shown } = lib
- useFocusRequest(focus, (target) => {
- const at = target.key === null ? -1 : positionOf(all, target.key)
- if (target.key === null || at < 0) return 'none'
- tiles.reveal(keys[at])
- if (referenceMatches(all[at], shown.view.query)) {
- return focusRowLater(target.key) ? 'found' : 'none'
- }
- shown.update({ query: '' })
- later(target.key)
+ layer: ReferenceLayer,
+): Show {
+ const later = useLateFocus()
+ return (key) => {
+ const at = positionOf(lib.all, key)
+ if (at < 0) return 'none'
+ const reference = lib.all[at]
+ lib.tiles.reveal(lib.keys[at])
+ const cited = lib.finding && citedIds(lib.finding)
+ const filtered = !!cited && !cited.includes(reference.id)
+ const matches = referenceMatches(reference, lib.shown.view.query)
+ if (matches && !filtered) return focusRowLater(key) ? 'found' : 'none'
+ if (filtered) layer.clearFilter()
+ if (!matches) lib.shown.update({ query: '' })
+ later(key)
return 'found'
- })
+ }
}
-/** What the library's controls do: search, « Ajouter une référence », edit and « Aller à ». */
-export function useReferenceActions(
- lib: ReferenceLibraryState,
- focus: FocusRequest | undefined,
- searchRef: RefObject,
+/** « Aller à » a reference: its tile is shown and focused. */
+function useReferenceFocus(focus: FocusRequest | undefined, show: Show) {
+ useFocusRequest(focus, (target) =>
+ target.key === null ? 'none' : show(target.key),
+ )
+}
+
+/** The notice of a reference just added: shown until « Afficher », or until it is gone. */
+function useAddedNotice(
+ all: readonly Reference[],
+ added: ReferenceLayer['added'],
+ show: Show,
) {
- const { keys, tiles, shown } = lib
- const [draft, setDraft] = useState(null)
- const later = useLateFocus()
- useReferenceFocus(focus, lib, later)
+ const [dismissed, setDismissed] = useState(0)
+ const reference = added && all.find((r) => r.id === added.id)
+ if (!added || !reference || added.serial === dismissed) return null
return {
- draft,
- clearSearch: () => {
- shown.update({ query: '' })
- searchRef.current?.focus()
- },
- // P24 (and P22): leave the tile in edit first, then a clean view and the draft.
- startAdd: () => {
- if (!tiles.finish()) return
- shown.reset(null)
- setDraft((serial) => (serial ?? 0) + 1)
- },
- // P24: the new tile is shown whatever was typed meanwhile, so the view is reset.
- added: (id: string) => {
- setDraft(null)
- shown.reset(tiles.editingKey)
- tiles.reveal(`${id}#0`)
- later({ kind: 'reference', id })
- },
- // C2: nothing was written; the search and sort reset by the add stay as they are.
- cancelAdd: () => {
- setDraft(null)
- document.getElementById(ADD_BUTTON_ID)?.focus()
- },
- edit: (position: number) => {
- if (tiles.startEdit(keys[position])) shown.markEdited(keys[position])
+ citation: reference.citation,
+ show: () => {
+ show({ kind: 'reference', id: added.id })
+ setDismissed(added.serial)
},
}
}
+
+/** What the library's controls do: search, « Ajouter une référence », « Modifier », « Aller à ». */
+export function useReferenceActions(
+ lib: ReferenceLibraryState,
+ focus: FocusRequest | undefined,
+ layer: ReferenceLayer,
+ searchRef: RefObject,
+) {
+ const show = useShowReference(lib, layer)
+ useReferenceFocus(focus, show)
+ return {
+ notice: useAddedNotice(lib.all, layer.added, show),
+ clearSearch: () => {
+ lib.shown.update({ query: '' })
+ searchRef.current?.focus()
+ },
+ startAdd: (opener: HTMLElement) => layer.start(opener),
+ edit: (position: number, opener: HTMLElement) =>
+ layer.open(lib.all[position].id, opener),
+ }
+}
diff --git a/apps/app/src/components/editor/references/useReferenceView.ts b/apps/app/src/components/editor/references/useReferenceView.ts
index feed1168..1612117a 100644
--- a/apps/app/src/components/editor/references/useReferenceView.ts
+++ b/apps/app/src/components/editor/references/useReferenceView.ts
@@ -26,70 +26,61 @@ interface Shown {
/**
* The search, the sort and the resulting tile order of the Références tab. All three are
- * display state: nothing here reaches the document (BDR-114). `resetSignal` (« Tout
- * afficher ») empties the search once per bump and keeps the sort (R2F-4); the tab stays
- * mounted (A2).
- * The tile that entered edit is pinned at the index it was shown at, whatever the search
- * or the sort, and stays pinned after « Terminer » until the next search or sort change,
- * so the tile the user just edited never vanishes under their focus (P23, I1). A
- * read-only flip keeps the pin: the tile in edit stays shown across it, with its note.
- * `editingKey` is the tile in edit, if any.
+ * display state: nothing here reaches the document (BDR-114), and the search is a personal
+ * search that never reaches the browser history. `resetSignal` (« Tout afficher ») empties
+ * the search once per bump and keeps the sort (R2F-4); the tab stays mounted (A2).
+ * `cited` (the ids one finding cites, null for none) narrows the list and the counts
+ * (R2F-6); it is navigation, held by the history.
+ * The tile the dialog edits (`editingKey`) is pinned at the index it was shown at, whatever
+ * the search or the sort, and stays pinned after the dialog closes until the next search
+ * or sort change, so the tile the user just edited never vanishes under their focus (P23,
+ * I1). With a filter nothing is pinned: a tile outside it never shows.
*/
export function useReferenceView(
{ all, keys, citers }: Shown,
editingKey: string | null,
resetSignal: number,
+ cited: ReadonlySet | null,
) {
const locale = useLocaleStore((state) => state.locale)
const [view, setView] = useState(INITIAL)
const [seen, setSeen] = useState(resetSignal)
const [pinned, setPinned] = useState(null)
- // The reset view is the sheet order: the tile in edit sits at its own position.
- const pinEdited = (key: string | null): Pinned | null =>
- key === null || !keys.includes(key)
- ? null
- : { key, index: keys.indexOf(key) }
if (seen !== resetSignal) {
setSeen(resetSignal)
setView({ ...view, query: '' })
- setPinned(pinEdited(editingKey))
+ setPinned(null)
}
- const pinAt = pinned === null ? -1 : keys.indexOf(pinned.key)
- const pin =
- pinned !== null && pinAt >= 0 && !isSheetView(view)
- ? { position: pinAt, index: pinned.index }
- : null
const context = {
locale,
citedCount: (id: string) => citers.get(id)?.length ?? 0,
}
- const positions = shownPositions(all, view, context, pin)
- // The count is the matches: a pinned tile the search misses is shown, not counted.
- const matchCount = all.filter((r) => referenceMatches(r, view.query)).length
- const pinAtShown = (key: string) =>
- Math.max(0, positions.indexOf(keys.indexOf(key)))
- // A new search or sort: the tile in edit stays where it is shown, any other pin ends.
- const pinAfterChange = (): Pinned | null => {
- if (pinned === null || pinned.key !== editingKey) return null
- return { key: pinned.key, index: pinAtShown(pinned.key) }
+ const plain = shownPositions(all, view, context, null, cited)
+ const editedAt = editingKey === null ? -1 : keys.indexOf(editingKey)
+ // Only a tile that is shown is pinned: a reference just created is not part of the list.
+ if (plain.includes(editedAt) && pinned?.key !== editingKey) {
+ setPinned({ key: editingKey as string, index: plain.indexOf(editedAt) })
}
+ const pinAt = pinned === null ? -1 : keys.indexOf(pinned.key)
+ const pin =
+ pinned !== null && pinAt >= 0 && !isSheetView(view, cited !== null)
+ ? { position: pinAt, index: Math.max(0, pinned.index) }
+ : null
+ const positions = shownPositions(all, view, context, pin, cited)
+ const inFilter = (r: Reference) => cited === null || cited.has(r.id)
+ // The count is the matches: a pinned tile the search misses is shown, not counted.
+ const matchCount = all.filter(
+ (r) => inFilter(r) && referenceMatches(r, view.query),
+ ).length
return {
view,
positions,
matchCount,
+ total: all.filter(inFilter).length,
+ filtered: cited !== null,
update: (patch: Partial) => {
- setPinned(pinAfterChange())
+ setPinned(null)
setView((current) => ({ ...current, ...patch }))
},
- /**
- * The clean view; `keep` is the tile still in edit, passed by the caller because a
- * `finish()` in the same handler has not reached this render's `editingKey` (M3).
- */
- reset: (keep: string | null) => {
- setView(INITIAL)
- setPinned(pinEdited(keep))
- },
- /** The tile `key` enters edit: remember where it is shown. */
- markEdited: (key: string) => setPinned({ key, index: pinAtShown(key) }),
}
}
diff --git a/apps/app/src/components/editor/references/useTileState.ts b/apps/app/src/components/editor/references/useTileState.ts
index 765ac34e..9b793317 100644
--- a/apps/app/src/components/editor/references/useTileState.ts
+++ b/apps/app/src/components/editor/references/useTileState.ts
@@ -1,5 +1,4 @@
-import { useRef, useState } from 'react'
-import type { LeaveGuard, Field } from './useReferenceEdit'
+import { useState } from 'react'
/**
* One key per tile: the id and its occurrence among equal ids, so a duplicated id stays
@@ -15,75 +14,25 @@ export function tileKeys(all: readonly { id: string }[]): string[] {
}
/**
- * Which tiles are open and which one is in edit. Lives in the library, which the tab keeps
- * mounted (A2), so both survive a tab change and reset when the editor is reopened.
- * Leaving the edit view asks the tile's guard first: a refusal keeps it (P22). `keys` are
- * the tiles the document has (null while it is not loaded): state of a tile that is gone
- * is dropped at once (P23').
+ * Which tiles are open. Lives in the library, which the tab keeps mounted (A2), so it
+ * survives a tab change and resets when the editor is reopened. `keys` are the tiles the
+ * document has (null while it is not loaded): state of a tile that is gone is dropped at
+ * once (P23'). Nothing here edits a tile: « Modifier » opens the reference dialog.
*/
export function useTileState(keys: readonly string[] | null) {
const [openKeys, setOpenKeys] = useState>(() => new Set())
- const [editingKey, setEditingKey] = useState(null)
if (keys !== null) {
const live = new Set(keys)
if ([...openKeys].some((key) => !live.has(key))) {
setOpenKeys(new Set([...openKeys].filter((key) => live.has(key))))
}
- if (editingKey !== null && !live.has(editingKey)) setEditingKey(null)
}
- const guard = useRef(null)
- // The tile a « Modifier » just opened: its edit view focuses Citation once, a remount
- // after a read-only interval does not (M1).
- const focusTicket = useRef(null)
- /** Applies the tile in edit; the fields that refused, none when nothing is left to apply. */
- const leave = (): Field[] => guard.current?.() ?? []
const open = (key: string) => setOpenKeys((prev) => new Set(prev).add(key))
- const finish = () => {
- if (leave().length > 0) return false
- setEditingKey(null)
- return true
- }
- // Read-only, the edit view is gone: a toggle ends the edit state and collapses.
- const toggle = (key: string, readOnly = false) => {
- if (editingKey === key) {
- if (!readOnly) return void finish()
- setEditingKey(null)
- return setOpenKeys((prev) => {
- const next = new Set(prev)
- next.delete(key)
- return next
- })
- }
+ const toggle = (key: string) =>
setOpenKeys((prev) => {
const next = new Set(prev)
if (!next.delete(key)) next.add(key)
return next
})
- }
- const startEdit = (key: string) => {
- if (editingKey !== null && editingKey !== key && leave().length > 0)
- return false
- focusTicket.current = key
- setEditingKey(key)
- open(key)
- return true
- }
- const takeFocus = (key: string) => {
- const mine = focusTicket.current === key
- if (mine) focusTicket.current = null
- return mine
- }
- return {
- openKeys,
- editingKey,
- toggle,
- startEdit,
- finish,
- leave,
- takeFocus,
- reveal: open,
- registerLeave: (next: LeaveGuard | null) => {
- guard.current = next
- },
- }
+ return { openKeys, toggle, reveal: open }
}
diff --git a/apps/app/src/components/editor/tabs/ReferencesTab.tsx b/apps/app/src/components/editor/tabs/ReferencesTab.tsx
index cc7890a1..f7026850 100644
--- a/apps/app/src/components/editor/tabs/ReferencesTab.tsx
+++ b/apps/app/src/components/editor/tabs/ReferencesTab.tsx
@@ -2,18 +2,20 @@ import { useRef, useState } from 'react'
import DeleteDialog, {
type DeleteTarget,
} from '@/components/editor/DeleteDialog'
-import EditOnly from '@/components/editor/EditOnly'
-import NewReferenceTile from '@/components/editor/references/NewReferenceTile'
+import Button from '@/components/ui/Button'
+import Notice from '@/components/ui/Notice'
import NoResult from '@/components/editor/references/NoResult'
import ReferenceTiles from '@/components/editor/references/ReferenceTiles'
import ReferenceToolbar from '@/components/editor/references/ReferenceToolbar'
import {
useReferenceActions,
useReferenceLibrary,
+ type ReferenceLibraryState,
} from '@/components/editor/references/useReferenceLibrary'
import { isSheetView } from '@/editor/references/view'
-import type { EditorPlaceProps } from '@/editor/tabs'
+import type { EditorPlaceProps, ReferenceLayer } from '@/editor/tabs'
import { useT } from '@/i18n/useT'
+import { useLocaleStore } from '@/state/localeStore'
/** The empty line: the sheet has no reference at all. */
function EmptyLine() {
@@ -27,21 +29,106 @@ function EmptyLine() {
type Props = Pick & {
resetSignal: number
+ layer: ReferenceLayer
+}
+
+/** « Référence ajoutée : … » with « Afficher »: the list did not move. */
+function AddedNotice({
+ citation,
+ onShow,
+}: {
+ citation: string
+ onShow: () => void
+}) {
+ const t = useT()
+ return (
+
+
+ {t('editor.references.added').replace('{citation}', () => citation)}
+
+ {t('editor.references.added_show')}
+
+
+
+ )
+}
+
+/** The chip of the finding the list is filtered by, null for the whole bibliography. */
+function useFilterChip(lib: ReferenceLibraryState, layer: ReferenceLayer) {
+ const locale = useLocaleStore((s) => s.locale)
+ const { finding } = lib
+ if (!finding || !layer.filter) return null
+ const key = layer.filter
+ return {
+ name: finding.name[locale],
+ onRemove: () => layer.clearFilter(),
+ onBack: () => layer.backToFinding(key),
+ }
+}
+
+type Actions = ReturnType
+
+interface BodyProps {
+ lib: ReferenceLibraryState
+ act: Actions
+ props: Props
+}
+
+/** The notice, the empty and no-result lines, the hint and the tiles. */
+function LibraryBody({ lib, act, props }: BodyProps) {
+ const t = useT()
+ const [deleting, setDeleting] = useState(null)
+ const { all, shown } = lib
+ const sheetView = isSheetView(shown.view, shown.filtered)
+ return (
+ <>
+ {act.notice && (
+
+ )}
+ {all.length === 0 && }
+ {all.length > 0 && shown.positions.length === 0 && (
+
+ )}
+ {!props.readOnly && !sheetView && shown.positions.length > 0 && (
+
+ {t('editor.references.reorder_hint')}
+
+ )}
+
+ setDeleting({
+ key: { kind: 'reference', id: reference.id },
+ label: reference.citation,
+ })
+ }
+ />
+ setDeleting(null)} />
+ >
+ )
}
/**
- * The sheet's bibliography: toolbar (search, sort, count, add), one collapsible tile per
- * reference, the draft tile and the delete dialog. Ids carry the `tab-` prefix. The
- * citations panel shares only the tile (R2.4).
+ * The sheet's bibliography: toolbar (search, sort, filter, count, add), one collapsible
+ * tile per reference and the delete dialog. « Modifier » and « Ajouter » open the
+ * reference dialog (a layer of the workspace). Ids carry the `tab-` prefix. The citations
+ * panel shares only the tile (R2.4).
*/
-function Library({ readOnly, navigate, focus, resetSignal }: Props) {
- const t = useT()
- const lib = useReferenceLibrary(resetSignal)
+function Library(props: Props) {
+ const lib = useReferenceLibrary(props.resetSignal, props.layer)
const searchRef = useRef(null)
- const act = useReferenceActions(lib, focus, searchRef)
- const [deleting, setDeleting] = useState(null)
- const { all, shown } = lib
- const sheetView = isSheetView(shown.view)
+ const act = useReferenceActions(lib, props.focus, props.layer, searchRef)
+ const chip = useFilterChip(lib, props.layer)
+ const { shown } = lib
return (
shown.update({ sort })}
shown={shown.matchCount}
- total={all.length}
- canAdd={!readOnly}
+ total={shown.total}
+ canAdd={!props.readOnly}
onAdd={act.startAdd}
+ filter={chip}
/>
- {lib.loaded && (
- <>
- {all.length === 0 && }
- {all.length > 0 && shown.positions.length === 0 && (
-
- )}
- {!readOnly && !sheetView && shown.positions.length > 0 && (
-
- {t('editor.references.reorder_hint')}
-
- )}
-
- setDeleting({
- key: { kind: 'reference', id: reference.id },
- label: reference.citation,
- })
- }
- />
-
- {act.draft !== null && (
-
- )}
-
- >
- )}
- setDeleting(null)} />
+ {lib.loaded && }
)
}
@@ -107,8 +155,11 @@ export default function ReferencesTab({
navigate,
focus,
libraryReset = 0,
+ references,
}: EditorPlaceProps) {
const t = useT()
+ if (!references)
+ throw new Error('Références needs the reference layer of the workspace')
return (
)
diff --git a/apps/app/src/editor/findingLayer.ts b/apps/app/src/editor/findingLayer.ts
index 24496f17..183a52d7 100644
--- a/apps/app/src/editor/findingLayer.ts
+++ b/apps/app/src/editor/findingLayer.ts
@@ -1,4 +1,4 @@
-import type { FindingLayer } from './tabs'
+import type { FindingLayer, ReferenceLayer } from './tabs'
import type { EditorNavigation } from './useEditorNavigation'
/** What Constats needs of the navigation for its dialog and the sheet over it. */
@@ -14,3 +14,14 @@ export function findingLayerOf(nav: EditorNavigation): FindingLayer {
announce: nav.announce,
}
}
+
+/** What the References tab and the reference dialog need of the navigation. */
+export function referenceLayerOf(nav: EditorNavigation): ReferenceLayer {
+ return {
+ view: nav.state.reference,
+ filter: nav.state.referenceFilter,
+ guards: nav.guards,
+ announce: nav.announce,
+ ...nav.references,
+ }
+}
diff --git a/apps/app/src/editor/focusRequest.ts b/apps/app/src/editor/focusRequest.ts
index 9df13545..4392df0a 100644
--- a/apps/app/src/editor/focusRequest.ts
+++ b/apps/app/src/editor/focusRequest.ts
@@ -174,8 +174,7 @@ export function focusActiveTab(options?: FocusOptions): void {
/**
* The element sits in a transactional form of an open dialog: the form keeps its draft
- * and its focus when the editor turns read-only, nothing moves it. (The citations
- * sheet's tiles still edit inline until the reference dialog: they are not drafts.)
+ * and its focus when the editor turns read-only, nothing moves it.
*/
function inOpenDialog(element: HTMLElement): boolean {
return element.closest('dialog[open] [data-draft-form]') !== null
diff --git a/apps/app/src/editor/history/entry.ts b/apps/app/src/editor/history/entry.ts
index 793b40a7..78b1f92b 100644
--- a/apps/app/src/editor/history/entry.ts
+++ b/apps/app/src/editor/history/entry.ts
@@ -68,11 +68,35 @@ function sanitizeFinding(raw: unknown, forms: boolean): EditorView['finding'] {
return { key, citations: sheet }
}
+/**
+ * The reference dialog of a view: over the References tab, or over the citations sheet
+ * (the only other place that opens it). A form, so only read back where forms are kept;
+ * whether the reference still exists is the dialog's own gone rule.
+ */
+function sanitizeReference(
+ raw: unknown,
+ finding: EditorView['finding'],
+ tab: unknown,
+): EditorView['reference'] {
+ if (!isRecord(raw)) return null
+ const sheet = !!finding && 'key' in finding && finding.citations
+ if (raw.create === true) return tab === 'references' ? { create: true } : null
+ const id = raw.edit
+ if (typeof id !== 'string' || id === '') return null
+ return tab === 'references' || sheet ? { edit: id } : null
+}
+
+/** The finding the References tab is filtered by: a finding node, on that tab only. */
+function sanitizeFilter(raw: unknown, tab: unknown): ElementKey | null {
+ const key = tab === 'references' ? sanitizeKey(raw) : null
+ return key && isFindingNode(key) ? key : null
+}
+
/**
* A view read back from a history entry, or null when it is no view. The finding layer
* must name a well-formed key and sit on the Constats tab; whether the element still
- * exists is the dialog's own gone rule. `forms` false drops the creation form (a reload
- * never reopens a form). The reference layer and the filter stay null until they exist.
+ * exists is the dialog's own gone rule. `forms` false drops the forms (a creation, the
+ * reference dialog): a reload never reopens a form.
*/
export function sanitizeView(raw: unknown, forms = true): EditorView | null {
if (!isRecord(raw)) return null
@@ -80,12 +104,15 @@ export function sanitizeView(raw: unknown, forms = true): EditorView | null {
const known = ANNOTATION_SECTIONS.includes(raw.section as AnnotationSection)
const finding =
raw.tab === 'findings' ? sanitizeFinding(raw.finding, forms) : null
+ const reference = forms
+ ? sanitizeReference(raw.reference, finding, raw.tab)
+ : null
return {
tab: raw.tab as EditorTabId,
section: known ? (raw.section as AnnotationSection) : 'drawing',
finding,
- reference: null,
- referenceFilter: null,
+ reference,
+ referenceFilter: sanitizeFilter(raw.referenceFilter, raw.tab),
}
}
@@ -147,19 +174,30 @@ function isRemoval(top: EditorView, view: EditorView): boolean {
/** What a changed view asks of the history. */
export type HistoryWrite = 'none' | 'push' | 'replace' | 'back'
+/** True when `view` shows the finding `key` (its dialog, with or without the sheet). */
+export function showsFinding(view: EditorView, key: ElementKey): boolean {
+ const { finding } = view
+ const shown = finding && 'key' in finding ? finding.key : null
+ return shown !== null && JSON.stringify(shown) === JSON.stringify(key)
+}
+
/**
* A user move to `view`. A layer taken away, or a section left for its drawing ("Retour
* au dessin"), goes back when the entry holds the view the move lands on (the entry that
* opened it), else it replaces; a layer, tab or section added pushes, unless the move
- * asked for a replace.
+ * asked for a replace. `backTo` (« Revenir au constat ») goes back when the entry below
+ * shows that finding.
*/
export function planWrite(
top: HistoryEntry,
view: EditorView,
replace: boolean,
+ backTo: ElementKey | null = null,
): HistoryWrite {
if (sameView(top.view, view)) return 'none'
if (replace) return 'replace'
+ // « Revenir au constat »: the entry below already shows that finding, a Back is the move.
+ if (backTo && top.below && showsFinding(top.below, backTo)) return 'back'
if (isRemoval(top.view, view)) {
return top.below && sameView(top.below, view) ? 'back' : 'replace'
}
diff --git a/apps/app/src/editor/history/useEditorHistory.ts b/apps/app/src/editor/history/useEditorHistory.ts
index 6ac135ac..916ed57e 100644
--- a/apps/app/src/editor/history/useEditorHistory.ts
+++ b/apps/app/src/editor/history/useEditorHistory.ts
@@ -120,12 +120,13 @@ function useReconcile(
writer: Writer,
) {
useEffect(() => {
- const { scrollY, replace } = nav.trace
+ const { scrollY, replace, backTo } = nav.trace
nav.trace.scrollY = null
nav.trace.replace = false
+ nav.trace.backTo = null
const top = book.entry
if (!top || book.pendingBack) return
- const plan = planWrite(top, view, replace)
+ const plan = planWrite(top, view, replace, backTo)
if (plan === 'none') return
book.scrolls.set(top.id, scrollY ?? window.scrollY)
if (plan === 'back') writer.back()
diff --git a/apps/app/src/editor/navigation.ts b/apps/app/src/editor/navigation.ts
index 011f80a9..cb6dca89 100644
--- a/apps/app/src/editor/navigation.ts
+++ b/apps/app/src/editor/navigation.ts
@@ -29,9 +29,9 @@ export interface FocusRequest {
/**
* 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; `citations` is
- * the side sheet over the finding dialog; `referenceFilter` narrows the references
- * library to the citers of an element. `reference` and `referenceFilter` stay null until
- * the reference dialog and the filter exist.
+ * the side sheet over the finding dialog; `reference` is the reference dialog above
+ * either; `referenceFilter` (only on the References tab) narrows the library to the
+ * references a finding cites. The search text is a personal search: never part of a view.
*/
export interface EditorView {
tab: EditorTabId
@@ -64,7 +64,11 @@ export type NavigationAction =
| { type: 'close_finding' }
| { type: 'open_citations'; citedBy: ElementKey }
| { type: 'close_citations' }
- | { type: 'show_all_references' }
+ | { type: 'open_reference'; id: string }
+ | { type: 'create_reference' }
+ | { type: 'close_reference' }
+ | { type: 'show_all_references'; filter: ElementKey }
+ | { type: 'clear_reference_filter' }
| { type: 'go_to'; target: EditorTarget }
| { type: 'restore_view'; view: EditorView }
| { type: 'focus_consumed'; serial: number }
@@ -115,6 +119,9 @@ function shown(state: NavigationState): NavigationState {
return { ...state, visitedTabs, visitedSections }
}
+/** What a move to another tab leaves behind: the reference dialog and the filter. */
+const LEFT_REFERENCES = { reference: null, referenceFilter: null } as const
+
const DEFAULT_VIEW = {
section: 'drawing',
finding: null,
@@ -207,7 +214,7 @@ function closeCitations(state: NavigationState): NavigationState {
/** The finding dialog of `key`, in view mode, on the Constats tab. */
function openFinding(state: NavigationState, key: ElementKey): NavigationState {
const finding = { key, citations: false }
- return shown({ ...state, tab: 'findings', finding })
+ return shown({ ...state, ...LEFT_REFERENCES, tab: 'findings', finding })
}
/** The creation form of a zone, a category or a node, on the Constats tab. */
@@ -215,40 +222,70 @@ function createFinding(
state: NavigationState,
create: { kind: string; parent: ElementKey | null },
): NavigationState {
- return shown({ ...state, tab: 'findings', finding: { create } })
+ const finding = { create }
+ return shown({ ...state, ...LEFT_REFERENCES, tab: 'findings', finding })
}
function goTo(state: NavigationState, target: EditorTarget): NavigationState {
const serial = state.serial + 1
+ // The filter survives only a move to the tab itself that names no reference.
+ const keep = target.tab === 'references' && target.key === null
const moved = {
...state,
tab: target.tab,
section: target.section ?? state.section,
finding: null,
+ reference: null,
+ referenceFilter: keep ? state.referenceFilter : null,
focus: { target, serial },
serial,
}
return shown(moved)
}
-/** « Tout afficher dans l'onglet Références »: the layers close, the library starts afresh. */
-function showAllReferences(state: NavigationState): NavigationState {
+/**
+ * « Tout afficher dans l'onglet Références »: the layers close, the library starts afresh
+ * and lists what `filter` (the finding the sheet belongs to) cites.
+ */
+function showAllReferences(
+ state: NavigationState,
+ filter: ElementKey,
+): NavigationState {
const moved = {
...state,
tab: 'references' as const,
finding: null,
+ reference: null,
+ referenceFilter: filter,
libraryReset: state.libraryReset + 1,
}
return shown(moved)
}
+/** A tab other than References has no filter: the filter belongs to that tab's view. */
+function selectTab(state: NavigationState, tab: EditorTabId): NavigationState {
+ const filter = tab === 'references' ? state.referenceFilter : null
+ const left = { finding: null, reference: null, referenceFilter: filter }
+ return shown({ ...state, ...left, tab })
+}
+
+/** The reference dialog of `id`, above the place (and the sheet) the view shows. */
+function openReference(state: NavigationState, id: string): NavigationState {
+ return shown({ ...state, reference: { edit: id } })
+}
+
+/** The creation form of a reference: only the References tab adds one. */
+function createReference(state: NavigationState): NavigationState {
+ return shown({ ...state, tab: 'references', reference: { create: true } })
+}
+
export function navigationReducer(
state: NavigationState,
action: NavigationAction,
): NavigationState {
switch (action.type) {
case 'select_tab':
- return shown({ ...state, tab: action.tab, finding: null })
+ return selectTab(state, action.tab)
case 'open_section':
return shown({ ...state, section: action.section })
case 'back_to_drawing':
@@ -263,8 +300,16 @@ export function navigationReducer(
return openCitations(state, action.citedBy)
case 'close_citations':
return closeCitations(state)
+ case 'open_reference':
+ return openReference(state, action.id)
+ case 'create_reference':
+ return createReference(state)
+ case 'close_reference':
+ return { ...state, reference: null }
case 'show_all_references':
- return showAllReferences(state)
+ return showAllReferences(state, action.filter)
+ case 'clear_reference_filter':
+ return { ...state, referenceFilter: null }
case 'go_to':
return goTo(state, action.target)
case 'restore_view':
diff --git a/apps/app/src/editor/references/view.ts b/apps/app/src/editor/references/view.ts
index e2bdc8ca..c7b600ab 100644
--- a/apps/app/src/editor/references/view.ts
+++ b/apps/app/src/editor/references/view.ts
@@ -7,9 +7,12 @@ export interface ReferenceView {
sort: ReferenceSort
}
-/** Stored order, no search: the only view where ↑ / ↓ mean something (A1). */
-export const isSheetView = (view: ReferenceView) =>
- view.sort === 'sheet' && view.query.trim() === ''
+/**
+ * Stored order, no search, no finding filter: the only view where ↑ / ↓ mean something
+ * (A1). `filtered` is true while the library lists one finding's citations (R2F-6).
+ */
+export const isSheetView = (view: ReferenceView, filtered = false) =>
+ !filtered && view.sort === 'sheet' && view.query.trim() === ''
/**
* The tile in edit, kept in the shown set at `index` whatever the search or the sort
@@ -20,18 +23,26 @@ export interface Pin {
index: number
}
-/** The positions to show: the search, then the sort, then the pinned tile put back. */
+/**
+ * The positions to show: the finding filter (`cited`, the ids that finding cites; null for
+ * none), the search, then the sort, then the pinned tile put back. A pin is for the
+ * unfiltered library only: a tile outside the filter never shows.
+ */
export function shownPositions(
references: readonly Reference[],
view: ReferenceView,
context: SortContext,
pin: Pin | null,
+ cited: ReadonlySet | null = null,
): number[] {
const matching = references.flatMap((reference, position) =>
- referenceMatches(reference, view.query) ? [position] : [],
+ referenceMatches(reference, view.query) &&
+ (cited === null || cited.has(reference.id))
+ ? [position]
+ : [],
)
const sorted = sortReferenceIds(references, matching, view.sort, context)
- if (pin === null) return sorted
+ if (pin === null || cited !== null) return sorted
const rest = sorted.filter((position) => position !== pin.position)
rest.splice(Math.min(pin.index, rest.length), 0, pin.position)
return rest
diff --git a/apps/app/src/editor/tabs.ts b/apps/app/src/editor/tabs.ts
index 3ce07c5c..9b7aa5df 100644
--- a/apps/app/src/editor/tabs.ts
+++ b/apps/app/src/editor/tabs.ts
@@ -3,6 +3,7 @@ import type { EditorTarget, EditorView, FocusRequest } from './navigation'
import { unmeasuredViews } from './issues'
import type { TabTier } from './useViewport'
import type { Guards } from './useEditorNavigation'
+import type { AddedReference } from './useReferenceMoves'
export const EDITOR_TABS = [
'general',
@@ -54,6 +55,27 @@ export interface FindingLayer {
announce: (text: string) => void
}
+/**
+ * What the References tab and the reference dialog need of the navigation (R2F-5, R2F-6):
+ * the layer and the filter the view holds, and the moves on them.
+ */
+export interface ReferenceLayer {
+ view: EditorView['reference']
+ /** The finding whose citations the library lists; null for the whole bibliography. */
+ filter: ElementKey | null
+ guards: Guards
+ open: (id: string, opener?: HTMLElement | null) => void
+ start: (opener?: HTMLElement | null) => void
+ close: (forced?: boolean) => boolean
+ replace: (id: string | null, text?: string) => void
+ created: (id: string) => void
+ added: AddedReference | null
+ opener: () => HTMLElement | null
+ clearFilter: (text?: string) => void
+ backToFinding: (key: ElementKey) => void
+ announce: (text: string) => void
+}
+
/** Props of every place (tab body, Annotations section). */
export interface EditorPlaceProps {
/** Not editable now: a mode that cannot save, or a recovery offer not answered yet. */
@@ -64,6 +86,8 @@ export interface EditorPlaceProps {
focus?: FocusRequest
/** The finding dialog and the citations sheet over it (only Constats has them). */
layer?: FindingLayer
+ /** The reference dialog and the filter (only the References tab and the sheet use them). */
+ references?: ReferenceLayer
/** Bumped by « Tout afficher »: the references library resets its search once per bump. */
libraryReset?: number
/** Reads the sheet's overview again (after a submission: the round freezes the draft). */
diff --git a/apps/app/src/editor/useEditorNavigation.ts b/apps/app/src/editor/useEditorNavigation.ts
index c11457a7..2059a691 100644
--- a/apps/app/src/editor/useEditorNavigation.ts
+++ b/apps/app/src/editor/useEditorNavigation.ts
@@ -33,6 +33,7 @@ import {
type NavigationState,
} from './navigation'
import { MORE_BUTTON_ID, tabDomId, type EditorTabId } from './tabs'
+import { useReferenceMoves, type ReferenceMoves } from './useReferenceMoves'
type MoveKind = 'go_to' | 'show_all' | 'tab_selected' | 'section' | 'back'
@@ -52,7 +53,7 @@ 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
+const LAYERS = ['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. */
@@ -72,6 +73,8 @@ export interface Guards {
export interface MoveTrace {
scrollY: number | null
replace: boolean
+ /** « Revenir au constat »: a Back when the entry below shows this finding. */
+ backTo: ElementKey | null
}
/** Options of a tab choice. */
@@ -107,8 +110,13 @@ export interface EditorNavigation {
closeCitations: () => boolean
/** « X références », where the focus returns once the sheet is closed. */
citationsTrigger: () => HTMLElement | null
- /** « Tout afficher dans l'onglet Références »: layers closed, tab shown, library reset. */
- showAllReferences: () => void
+ /**
+ * « Tout afficher dans l'onglet Références »: layers closed, tab shown, library reset
+ * and filtered by the finding the sheet belongs to.
+ */
+ showAllReferences: (filter: ElementKey) => void
+ /** The reference dialog and the References tab's filter. */
+ references: ReferenceMoves
guards: Guards
trace: MoveTrace
/** A Back or Forward landed on `view` (the history adapter's way in): no move, no request. */
@@ -197,11 +205,16 @@ function useGuards(): Guards {
}
function useMoveTrace() {
- const trace = useRef({ scrollY: null, replace: false }).current
+ const trace = useRef({
+ scrollY: null,
+ replace: false,
+ backTo: null,
+ }).current
const mark = useCallback(
(replace = false) => {
trace.scrollY = window.scrollY
trace.replace = replace
+ trace.backTo = null
},
[trace],
)
@@ -227,6 +240,7 @@ function useGo(dispatch: Dispatch, trace: MoveTrace) {
announce(text)
trace.scrollY = window.scrollY
trace.replace = false
+ trace.backTo = null
dispatch(action)
setMove({ kind })
},
@@ -255,7 +269,7 @@ function useSectionMoves(go: Go, openers: Openers) {
}
/** What the layers' moves need of the hook. */
-interface LayerContext {
+export interface LayerContext {
dispatch: Dispatch
announce: (text: string) => void
guards: Guards
@@ -315,7 +329,7 @@ function useFindingClosing({ dispatch, announce, guards, mark }: LayerContext) {
/** The citations sheet over the finding dialog: opened from a finding node only. */
function useSheetLayer(ctx: LayerContext, openers: Openers) {
- const { dispatch, guards, mark } = ctx
+ const { dispatch, mark } = ctx
const openCitations = useCallback(
(citedBy: ElementKey, opener?: Opener) => {
if (!isFindingNode(citedBy)) return
@@ -327,11 +341,10 @@ function useSheetLayer(ctx: LayerContext, openers: Openers) {
[openers, dispatch, mark],
)
const closeCitations = useCallback(() => {
- if (!guards.ask('citations', false).allowed) return false
mark()
dispatch({ type: 'close_citations' })
return true
- }, [guards, dispatch, mark])
+ }, [dispatch, mark])
return { openCitations, closeCitations }
}
@@ -346,11 +359,14 @@ function useLeavingMoves(go: Go, guards: Guards) {
},
[go, guards, moveText],
)
- const showAllReferences = useCallback(() => {
- if (!guards.askAll(false).allowed) return
- const text = t('editor.tab.references')
- go({ type: 'show_all_references' }, 'show_all', text)
- }, [go, guards, t])
+ const showAllReferences = useCallback(
+ (filter: ElementKey) => {
+ if (!guards.askAll(false).allowed) return
+ const text = t('editor.tab.references')
+ go({ type: 'show_all_references', filter }, 'show_all', text)
+ },
+ [go, guards, t],
+ )
return { navigate, showAllReferences }
}
@@ -497,6 +513,7 @@ export function useEditorNavigation(
...useFindingLayer(ctx),
...useSheetLayer(ctx, openers),
...useLeavingMoves(base.go, guards),
+ references: useReferenceMoves(ctx, base.trace),
citationsTrigger: useCallback(() => triggerOf(openers), [openers]),
guards,
trace: base.trace,
diff --git a/apps/app/src/editor/useReferenceMoves.ts b/apps/app/src/editor/useReferenceMoves.ts
new file mode 100644
index 00000000..f1f27ba3
--- /dev/null
+++ b/apps/app/src/editor/useReferenceMoves.ts
@@ -0,0 +1,147 @@
+import { useCallback, useRef, useState, type RefObject } from 'react'
+import type { ElementKey } from '@faunosteo/core-wasm/types'
+import type { LayerContext, MoveTrace } from './useEditorNavigation'
+
+/** The reference a creation just made: the library shows a notice for it, once per serial. */
+export interface AddedReference {
+ id: string
+ serial: number
+}
+
+type Opener = HTMLElement | null | undefined
+
+/** What the reference dialog (R2F-5) and the References tab's filter (R2F-6) do to the view. */
+export interface ReferenceMoves {
+ /** The dialog of reference `id`, over the place the view shows. */
+ open: (id: string, opener?: Opener) => void
+ /** The creation dialog, over the References tab. */
+ start: (opener?: Opener) => void
+ /** A user close; false when the form refused it (a dirty draft asks first). */
+ close: (forced?: boolean) => boolean
+ /**
+ * The dialog becomes another view of itself, by replace (no Back entry): `null` closes
+ * it. With `text`, a close the user did not ask for (the reference vanished): forced,
+ * said once the dialogs are closed.
+ */
+ replace: (id: string | null, text?: string) => void
+ /** A creation succeeded: its entry becomes the reference's own, then the dialog closes. */
+ created: (id: string) => void
+ added: AddedReference | null
+ /** The element that opened the dialog, while it is still on the page. */
+ opener: () => HTMLElement | null
+ /** « × » of the filter chip, or a vanished finding (`text` says so): a replace. */
+ clearFilter: (text?: string) => void
+ /** « Revenir au constat »: a Back when the entry below shows it, else its dialog. */
+ backToFinding: (key: ElementKey) => void
+}
+
+/** The moves that add the dialog: an edit of a reference, a creation. */
+function useOpening({ dispatch, mark }: LayerContext, held: RefObject) {
+ const open = useCallback(
+ (id: string, opener?: Opener) => {
+ held.current = opener
+ mark()
+ dispatch({ type: 'open_reference', id })
+ },
+ [dispatch, mark, held],
+ )
+ const start = useCallback(
+ (opener?: Opener) => {
+ held.current = opener
+ mark()
+ dispatch({ type: 'create_reference' })
+ },
+ [dispatch, mark, held],
+ )
+ return { open, start }
+}
+
+/** The moves that take it away: a user close, and the replace that is no Back step. */
+function useClosing({ dispatch, announce, guards, mark }: LayerContext) {
+ const close = useCallback(
+ (forced = false) => {
+ if (!guards.ask('reference', forced).allowed) return false
+ mark()
+ dispatch({ type: 'close_reference' })
+ return true
+ },
+ [guards, dispatch, mark],
+ )
+ const replace = useCallback(
+ (id: string | null, text?: string) => {
+ const note = text ? guards.ask('reference', true).note : undefined
+ if (text) announce(note ? `${note}. ${text}` : text)
+ mark(true)
+ dispatch(
+ id ? { type: 'open_reference', id } : { type: 'close_reference' },
+ )
+ },
+ [guards, announce, dispatch, mark],
+ )
+ return { close, replace }
+}
+
+/** A creation that succeeded: its entry becomes the reference's own, then it closes. */
+function useCreated(
+ { dispatch, mark }: LayerContext,
+ replace: ReferenceMoves['replace'],
+) {
+ const [added, setAdded] = useState(null)
+ const created = useCallback(
+ (id: string) => {
+ replace(id)
+ setAdded((last) => ({ id, serial: (last?.serial ?? 0) + 1 }))
+ // After the commit that wrote the replace: the entry is the reference's own before
+ // the close goes back over it, so a Forward never reopens a creation.
+ queueMicrotask(() => {
+ mark()
+ dispatch({ type: 'close_reference' })
+ })
+ },
+ [replace, mark, dispatch],
+ )
+ return { created, added }
+}
+
+/** The filter's two moves: remove it by replace, return to the finding it names. */
+function useFilter(
+ { dispatch, announce, mark }: LayerContext,
+ trace: MoveTrace,
+) {
+ const clearFilter = useCallback(
+ (text?: string) => {
+ if (text) announce(text)
+ mark(true)
+ dispatch({ type: 'clear_reference_filter' })
+ },
+ [announce, dispatch, mark],
+ )
+ const backToFinding = useCallback(
+ (key: ElementKey) => {
+ mark()
+ trace.backTo = key
+ dispatch({ type: 'open_finding', key })
+ },
+ [dispatch, mark, trace],
+ )
+ return { clearFilter, backToFinding }
+}
+
+export function useReferenceMoves(
+ ctx: LayerContext,
+ trace: MoveTrace,
+): ReferenceMoves {
+ const held = useRef(null)
+ const opener = useCallback((): HTMLElement | null => {
+ const element = held.current
+ return element?.isConnected && !element.closest('[hidden]') ? element : null
+ }, [held])
+ const closing = useClosing(ctx)
+ return {
+ ...useOpening(ctx, held),
+ ...closing,
+ ...useCreated(ctx, closing.replace),
+ ...useFilter(ctx, trace),
+ opener,
+ }
+}
diff --git a/apps/app/tests/unit/editor-references-flip.test.tsx b/apps/app/tests/unit/editor-references-flip.test.tsx
deleted file mode 100644
index c96dd899..00000000
--- a/apps/app/tests/unit/editor-references-flip.test.tsx
+++ /dev/null
@@ -1,620 +0,0 @@
-/**
- * C1: a read-only flip never drops a draft silently, writes nothing, and keeps the tile.
- * I1: a user leave with several refused fields focuses the first one, with its own error.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { act, cleanup, screen, waitFor, within } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { useLocaleStore } from '@/state/localeStore'
-import { edit, insert } from '../helpers/editorFixtures'
-import {
- baseText,
- resetStore,
- serverHas,
- store,
-} from '../helpers/editorHarness'
-import {
- findingDialog,
- inFindingDialog,
- openFinding,
-} from '../helpers/findingDialog'
-import { mountDraft, setWidth } from '../helpers/editorRoute'
-
-vi.mock('@/lib/supabase', () => ({ getSupabaseClient: () => ({}) }))
-vi.mock('@faunosteo/supabase', async (orig) => ({
- ...(await orig()),
- getSheetVersion: vi.fn(),
- downloadSheetDrawing: vi.fn(),
- saveSheetDraft: vi.fn(),
- getOfficialSheetAdmin: vi.fn(),
- submitSheetReview: vi.fn(),
-}))
-
-beforeEach(() => useLocaleStore.setState({ locale: 'fr' }))
-/** Every watcher made by `watchNotes`: stopped after each test, even a failing one. */
-const watchers: { stop: () => void }[] = []
-afterEach(() => {
- watchers.splice(0).forEach((watch) => watch.stop())
- cleanup()
- resetStore()
- setWidth(1024)
-})
-
-const name = (n: string) => ({ fr: n, en: n })
-const ref = (id: string, citation: string, url = '') =>
- ({
- kind: 'reference',
- value: { id, type: 'book', citation, url: url || null, doi: null },
- }) as const
-
-/** Three references (ref-b has a URL) and Node A citing ref-a and ref-b. */
-function sheetText(): string {
- let text = baseText()
- text = insert(text, ref('ref-a', 'Barone, Ostéologie'))
- text = insert(text, ref('ref-b', 'Denoix', 'https://exemple.org/Épaule'))
- text = insert(text, ref('ref-c', 'Code rural'))
- text = insert(text, {
- kind: 'zone',
- value: { id: 'zone-a', name: name('Zone A'), categories: [] },
- })
- text = edit(text, {
- op: 'insert',
- parent: { kind: 'zone', id: 'zone-a' },
- element: {
- kind: 'finding_category',
- value: {
- id: 'fcat-a',
- kind: 'dysfunction',
- name: name('Cat A'),
- description: {},
- reference_ids: [],
- review_status: 'to_confirm',
- children: [],
- },
- },
- })
- return edit(text, {
- op: 'insert',
- parent: { kind: 'finding', zone_id: 'zone-a', path: ['fcat-a'] },
- element: {
- kind: 'finding_node',
- value: {
- id: 'fnode-a',
- name: name('Node A'),
- description: {},
- requires_vet_referral: false,
- reference_ids: ['ref-a', 'ref-b'],
- review_status: 'to_confirm',
- children: [],
- },
- },
- })
-}
-
-type User = ReturnType
-const NOTE = 'Saisie non appliquée'
-const live = () => document.querySelector('p.sr-only[aria-live="polite"]')!
-const doc = () => JSON.parse(store.getState().documentText)
-const history = () => ({
- undo: store.getState().undo.length,
- redo: store.getState().redo.length,
-})
-const cross = (width: number) =>
- act(() => {
- setWidth(width)
- window.dispatchEvent(new Event('resize'))
- })
-
-const flush = () => act(async () => undefined)
-
-/** The prototype object that owns a property, so a wrapper can be put back exactly. */
-function ownerOf(target: object, property: string): object {
- let owner: object | null = target
- while (owner && !Object.hasOwn(owner, property)) {
- owner = Object.getPrototypeOf(owner)
- }
- return owner!
-}
-
-/**
- * Counts the live region's updates that carry the drop note. It wraps the two DOM setters
- * React uses for a text change (`textContent`, `nodeValue`) instead of using a
- * MutationObserver: happy-dom keeps an observer's callback in a WeakRef, so a garbage
- * collection under load silently ends the observation (seen as a missed announcement).
- */
-function watchNotes() {
- const seen: string[] = []
- const restore: (() => void)[] = []
- const wrap = (target: object, property: string) => {
- const owner = ownerOf(target, property)
- const original = Object.getOwnPropertyDescriptor(owner, property)!
- Object.defineProperty(owner, property, {
- ...original,
- set(this: Node, value: string) {
- original.set!.call(this, value)
- const region = live()
- if (region.contains(this) && region.textContent?.includes(NOTE)) {
- seen.push(region.textContent)
- }
- },
- })
- restore.push(() => Object.defineProperty(owner, property, original))
- }
- wrap(live(), 'textContent')
- wrap(document.createTextNode(''), 'nodeValue')
- const watch = { seen, stop: () => restore.forEach((undo) => undo()) }
- watchers.push(watch)
- return watch
-}
-
-async function mount(width = 1280) {
- serverHas(sheetText(), 3)
- const user = userEvent.setup()
- mountDraft({ width, strict: true })
- await screen.findByRole('heading', { level: 1, name: 'Brouillon, version 4' })
- return user
-}
-
-const tabPanel = () => screen.getByRole('tabpanel', { name: 'Références' })
-const header = (id: string, host = 'tab') =>
- document.querySelector(
- `button[id^="${host}-reference-"][id$="-${id}-header"]`,
- )!
-const tile = (id: string, host = 'tab') => header(id, host).closest('li')!
-const field = (id: string, name: string, host = 'tab') =>
- document.querySelector(
- `#${host}-reference-${id === 'ref-a' ? 0 : id === 'ref-b' ? 1 : 2}-${id}-${name}`,
- )!
-
-/** « Références », the tile open and in edit; the focus on its Citation field. */
-async function editTile(user: User, id: string, label: RegExp) {
- await user.click(screen.getByRole('tab', { name: 'Références' }))
- await user.click(within(tabPanel()).getByRole('button', { name: label }))
- await user.click(within(tile(id)).getByRole('button', { name: 'Modifier' }))
-}
-
-/** Types a schemeless URL (refused) in the focused-then-kept URL field of `id`. */
-async function typeBadUrl(user: User, id: string) {
- const url = field(id, 'url')
- await user.clear(url)
- await user.type(url, 'exemple.org')
- return url
-}
-
-describe('a read-only flip with a refused draft (tab tile)', () => {
- it('shows the note, says it once, writes nothing, focuses the tile', async () => {
- const user = await mount()
- await editTile(user, 'ref-b', /^Denoix/)
- await typeBadUrl(user, 'ref-b')
- const before = { references: doc().references, ...history() }
- const watch = watchNotes()
- cross(800)
- expect(
- within(tile('ref-b')).getByText(`${NOTE} : Adresse web (URL)`),
- ).toBeVisible()
- expect(within(tile('ref-b')).queryByRole('textbox')).toBeNull()
- expect(
- within(tile('ref-b')).getByText('https://exemple.org/Épaule'),
- ).toBeVisible()
- await flush()
- expect(watch.seen).toHaveLength(1)
- expect(live().textContent).toBe(`${NOTE} : Adresse web (URL)`)
- expect({ references: doc().references, ...history() }).toEqual(before)
- expect(document.activeElement).toBe(header('ref-b'))
- watch.stop()
- })
-
- it('keeps the note across the flip back; Terminer removes it', async () => {
- const user = await mount()
- await editTile(user, 'ref-b', /^Denoix/)
- await typeBadUrl(user, 'ref-b')
- cross(800)
- await flush()
- const watch = watchNotes()
- cross(1280)
- await flush()
- expect(watch.seen).toHaveLength(0)
- watch.stop()
- const item = tile('ref-b')
- expect(within(item).getByText(`${NOTE} : Adresse web (URL)`)).toBeVisible()
- expect(field('ref-b', 'url')).toHaveValue('https://exemple.org/Épaule')
- expect(history()).toEqual({ undo: 0, redo: 0 })
- await user.click(within(item).getByRole('button', { name: 'Terminer' }))
- expect(within(item).queryByText(new RegExp(NOTE))).toBeNull()
- })
-
- it('the read-only toggle ends the edit state, collapses and clears the note', async () => {
- const user = await mount()
- await editTile(user, 'ref-b', /^Denoix/)
- await typeBadUrl(user, 'ref-b')
- cross(800)
- await user.click(header('ref-b'))
- expect(header('ref-b')).toHaveAttribute('aria-expanded', 'false')
- expect(within(tile('ref-b')).queryByText(new RegExp(NOTE))).toBeNull()
- cross(1280)
- expect(header('ref-b')).toHaveAttribute('aria-expanded', 'false')
- expect(within(tile('ref-b')).queryByRole('textbox')).toBeNull()
- })
-
- it('names both refused fields, in field order', async () => {
- const user = await mount()
- await editTile(user, 'ref-b', /^Denoix/)
- await user.clear(field('ref-b', 'citation'))
- await typeBadUrl(user, 'ref-b')
- cross(800)
- expect(
- within(tile('ref-b')).getByText(`${NOTE} : Citation, Adresse web (URL)`),
- ).toBeVisible()
- expect(doc().references[1].citation).toBe('Denoix')
- })
-
- it('keeps the tile in edit shown when the search does not match it', async () => {
- const user = await mount()
- await editTile(user, 'ref-b', /^Denoix/)
- await user.type(
- within(tabPanel()).getByRole('searchbox', {
- name: 'Rechercher une référence',
- }),
- 'rural',
- )
- expect(header('ref-b')).not.toBeNull()
- await typeBadUrl(user, 'ref-b')
- cross(800)
- expect(
- within(tile('ref-b')).getByText(`${NOTE} : Adresse web (URL)`),
- ).toBeVisible()
- expect(header('ref-c')).not.toBeNull()
- })
-})
-
-describe('the note ends on the next action', () => {
- /** ref-b flipped with a refused URL and back: in edit again, note shown. */
- async function flippedBack() {
- const user = await mount()
- await editTile(user, 'ref-b', /^Denoix/)
- await typeBadUrl(user, 'ref-b')
- cross(800)
- cross(1280)
- expect(
- within(tile('ref-b')).getByText(/Saisie non appliquée/),
- ).toBeVisible()
- return user
- }
- const noted = () => within(tabPanel()).queryAllByText(/Saisie non appliquée/)
-
- it("ends on another tile's « Modifier » (this tile leaves edit)", async () => {
- const user = await flippedBack()
- await user.click(
- within(tabPanel()).getByRole('button', { name: /^Barone/ }),
- )
- await user.click(
- within(tile('ref-a')).getByRole('button', { name: 'Modifier' }),
- )
- expect(noted()).toHaveLength(0)
- })
-
- it('ends on « Ajouter une référence »', async () => {
- const user = await flippedBack()
- await user.click(
- within(tabPanel()).getByRole('button', { name: 'Ajouter une référence' }),
- )
- expect(noted()).toHaveLength(0)
- })
-
- it('is replaced by a newer drop of the same tile, announced again', async () => {
- const user = await flippedBack()
- const watch = watchNotes()
- await user.clear(field('ref-b', 'citation'))
- await typeBadUrl(user, 'ref-b')
- cross(800)
- await flush()
- const items = noted()
- expect(items).toHaveLength(1)
- expect(items[0]).toHaveTextContent(`${NOTE} : Citation, Adresse web (URL)`)
- expect(watch.seen).toHaveLength(1)
- watch.stop()
- })
-})
-
-describe('a read-only flip without a refused draft', () => {
- it('adds only the typed change when a valid draft has the focus', async () => {
- const user = await mount()
- await editTile(user, 'ref-a', /^Barone/)
- const citation = field('ref-a', 'citation')
- await user.clear(citation)
- await user.type(citation, 'Neuf')
- const watch = watchNotes()
- cross(800)
- expect(history()).toEqual({ undo: 1, redo: 0 })
- expect(doc().references[0].citation).toBe('Neuf')
- expect(within(tile('ref-a')).queryByText(new RegExp(NOTE))).toBeNull()
- expect(document.activeElement).toBe(header('ref-a'))
- cross(1280)
- await flush()
- expect(history()).toEqual({ undo: 1, redo: 0 })
- expect(watch.seen).toHaveLength(0)
- watch.stop()
- })
-
- it('writes nothing, says nothing and shows no note when nothing is pending', async () => {
- const user = await mount()
- await editTile(user, 'ref-a', /^Barone/)
- const watch = watchNotes()
- cross(800)
- cross(1280)
- await flush()
- expect(history()).toEqual({ undo: 0, redo: 0 })
- expect(watch.seen).toHaveLength(0)
- expect(screen.queryByText(new RegExp(NOTE))).toBeNull()
- watch.stop()
- })
-})
-
-describe('an undo that removes a tile holding a refused draft (V1)', () => {
- const added = (name: string) =>
- document.querySelector(`#tab-reference-3-ref-d-${name}`)!
-
- /** ref-d inserted by one history entry, then its tile in edit. */
- async function editInserted() {
- const user = await mount()
- act(() => {
- store
- .getState()
- .commit({ op: 'insert', element: ref('ref-d', 'Nouvelle') })
- })
- expect(history()).toEqual({ undo: 1, redo: 0 })
- await editTile(user, 'ref-d', /^Nouvelle/)
- return user
- }
-
- /** From a valid place: « Défaire » pressed from a refused field only refocuses it. */
- async function undoInsertion(user: User) {
- await user.tab()
- expect(document.activeElement).not.toHaveAttribute('aria-invalid', 'true')
- const watch = watchNotes()
- await user.click(screen.getByRole('button', { name: /Défaire/ }))
- await flush()
- expect(header('ref-d')).toBeNull()
- expect(doc().references.map((r: { id: string }) => r.id)).toEqual([
- 'ref-a',
- 'ref-b',
- 'ref-c',
- ])
- expect(history()).toEqual({ undo: 0, redo: 1 })
- return watch
- }
-
- it('says the dropped Citation once', async () => {
- const user = await editInserted()
- await user.clear(added('citation'))
- const watch = await undoInsertion(user)
- expect(watch.seen).toEqual([`${NOTE} : Citation`])
- watch.stop()
- })
-
- it('names both refused fields, once', async () => {
- const user = await editInserted()
- await user.clear(added('citation'))
- await user.click(added('url'))
- await user.type(added('url'), 'exemple.org')
- const watch = await undoInsertion(user)
- expect(watch.seen).toEqual([`${NOTE} : Citation, Adresse web (URL)`])
- watch.stop()
- })
-})
-
-/** The citations panel of Node A, its Denoix tile in edit. */
-async function openPanel(user: User) {
- await user.click(screen.getByRole('tab', { name: 'Constats' }))
- await openFinding(user, /Node A/)
- await user.click(
- inFindingDialog().getByRole('button', { name: '2 références' }),
- )
- await waitFor(() =>
- expect(document.activeElement).toBe(
- screen.getByRole('button', { name: 'Fermer les références' }),
- ),
- )
- const panel = screen.getByTestId('editor-citations-panel')
- await user.click(within(panel).getByRole('button', { name: /^Denoix/ }))
- await user.click(within(panel).getByRole('button', { name: 'Modifier' }))
- return panel
-}
-
-/** The sheet, then the finding dialog under it, closed with their ✕. */
-async function closeLayers(user: User) {
- await user.click(
- screen.getByRole('button', { name: 'Fermer les références' }),
- )
- await waitFor(() =>
- expect(screen.queryByTestId('editor-citations-panel')).toBeNull(),
- )
- await user.click(
- within(findingDialog()!).getByRole('button', { name: 'Fermer' }),
- )
- await waitFor(() => expect(document.querySelector('dialog[open]')).toBeNull())
-}
-
-describe('a read-only flip in the citations panel', () => {
- it('shows the note in the panel tile, says it once, focuses the tile header', async () => {
- const user = await mount()
- await openPanel(user)
- await typeBadUrlIn(user)
- const watch = watchNotes()
- cross(800)
- const item = tile('ref-b', 'panel')
- expect(within(item).getByText(`${NOTE} : Adresse web (URL)`)).toBeVisible()
- await flush()
- // the page is inert under the two dialogs: the announcement waits for them
- expect(watch.seen).toHaveLength(0)
- expect(document.activeElement).toBe(header('ref-b', 'panel'))
- expect(history()).toEqual({ undo: 0, redo: 0 })
- await closeLayers(user)
- await waitFor(() => expect(watch.seen).toHaveLength(1))
- watch.stop()
- })
-
- it('a forced close names every refused field and says it once', async () => {
- const user = await mount()
- await openPanel(user)
- await user.clear(field('ref-b', 'citation', 'panel'))
- await typeBadUrlIn(user)
- const watch = watchNotes()
- act(() => {
- store.getState().commit({
- op: 'remove',
- key: {
- kind: 'finding',
- zone_id: 'zone-a',
- path: ['fcat-a', 'fnode-a'],
- },
- })
- })
- await waitFor(() =>
- expect(screen.queryByTestId('editor-citations-panel')).toBeNull(),
- )
- // The forced close announces in a later commit than the panel's exit: wait for
- // the text itself, then let any second announcement land before counting.
- await waitFor(() =>
- expect(live().textContent).toContain(
- `${NOTE} : Citation, Adresse web (URL)`,
- ),
- )
- await flush()
- expect(watch.seen).toHaveLength(1)
- watch.stop()
- })
-})
-
-describe('an undo that takes a tile holding a refused draft out of the panel (V1)', () => {
- it('says the dropped Citation once, the panel stays', async () => {
- const user = await mount()
- act(() => {
- store.getState().commit({
- op: 'update',
- key: {
- kind: 'finding',
- zone_id: 'zone-a',
- path: ['fcat-a', 'fnode-a'],
- },
- element: {
- kind: 'finding_node',
- value: {
- ...doc().finding_zones[0].categories[0].children[0],
- reference_ids: ['ref-a', 'ref-b', 'ref-c'],
- },
- },
- })
- })
- expect(history()).toEqual({ undo: 1, redo: 0 })
- await user.click(screen.getByRole('tab', { name: 'Constats' }))
- await openFinding(user, /Node A/)
- await user.click(
- inFindingDialog().getByRole('button', { name: '3 références' }),
- )
- const panel = await screen.findByTestId('editor-citations-panel')
- await user.click(within(panel).getByRole('button', { name: /^Code rural/ }))
- await user.click(within(panel).getByRole('button', { name: 'Modifier' }))
- await user.clear(field('ref-c', 'citation', 'panel'))
- await user.tab()
- const watch = watchNotes()
- await user.click(screen.getByRole('button', { name: /Défaire/ }))
- await flush()
- expect(header('ref-c', 'panel')).toBeNull()
- expect(screen.getByTestId('editor-citations-panel')).toBe(panel)
- expect(history()).toEqual({ undo: 0, redo: 1 })
- // said once the sheet and the finding dialog under it are closed
- expect(watch.seen).toEqual([])
- await closeLayers(user)
- await waitFor(() => expect(watch.seen).toEqual([`${NOTE} : Citation`]))
- watch.stop()
- })
-})
-
-async function typeBadUrlIn(user: User) {
- const url = field('ref-b', 'url', 'panel')
- await user.clear(url)
- await user.type(url, 'exemple.org')
-}
-
-const REQUIRED = 'Ce champ est obligatoire.'
-
-/** Citation cleared then a schemeless URL, both refused, in the tile `id` of `host`. */
-async function twoRefused(user: User, id: string, host = 'tab') {
- await user.clear(field(id, 'citation', host))
- await user.tab()
- const url = field(id, 'url', host)
- await user.clear(url)
- await user.type(url, 'exemple.org')
-}
-
-/** I1: the field focused by a refused leave shows its own refusal; no draft is lost. */
-function expectCitationRefused(id: string, host = 'tab') {
- const citation = field(id, 'citation', host)
- expect(document.activeElement).toBe(citation)
- expect(citation).toHaveAttribute('aria-invalid', 'true')
- expect(citation).toHaveAccessibleDescription(REQUIRED)
- expect(citation).toHaveValue('')
-}
-
-describe('a user leave with several refused fields (I1)', () => {
- it('keyboard « Terminer » focuses Citation with its own error', async () => {
- const user = await mount()
- await editTile(user, 'ref-b', /^Denoix/)
- await twoRefused(user, 'ref-b')
- const done = within(tile('ref-b')).getByRole('button', { name: 'Terminer' })
- for (let step = 0; step < 6 && document.activeElement !== done; step++) {
- await user.tab()
- }
- expect(document.activeElement).toBe(done)
- await user.keyboard('{Enter}')
- expect(done).toBeInTheDocument()
- expectCitationRefused('ref-b')
- expect(field('ref-b', 'url')).toHaveValue('exemple.org')
- expect(history()).toEqual({ undo: 0, redo: 0 })
- })
-
- it("another tile's « Modifier » focuses Citation with its own error", async () => {
- const user = await mount()
- await editTile(user, 'ref-b', /^Denoix/)
- await twoRefused(user, 'ref-b')
- await user.click(
- within(tabPanel()).getByRole('button', { name: /^Barone/ }),
- )
- await user.click(
- within(tile('ref-a')).getByRole('button', { name: 'Modifier' }),
- )
- expect(field('ref-a', 'citation')).toBeNull()
- expectCitationRefused('ref-b')
- expect(field('ref-b', 'url')).toHaveValue('exemple.org')
- })
-
- it('the panel ✕ is cancelled, Citation focused with its own error', async () => {
- const user = await mount()
- const panel = await openPanel(user)
- await twoRefused(user, 'ref-b', 'panel')
- await user.click(
- within(panel).getByRole('button', { name: 'Fermer les références' }),
- )
- expect(screen.getByTestId('editor-citations-panel')).toBe(panel)
- expectCitationRefused('ref-b', 'panel')
- expect(field('ref-b', 'url', 'panel')).toHaveValue('exemple.org')
- expect(history()).toEqual({ undo: 0, redo: 0 })
- })
-
- it('a mouse « Terminer » with a valid URL focused keeps edit on Citation', async () => {
- const user = await mount()
- await editTile(user, 'ref-b', /^Denoix/)
- await user.clear(field('ref-b', 'citation'))
- await user.tab()
- const url = field('ref-b', 'url')
- await user.clear(url)
- await user.type(url, 'https://exemple.org/neuf')
- const done = within(tile('ref-b')).getByRole('button', { name: 'Terminer' })
- await user.click(done)
- expect(done).toBeInTheDocument()
- expectCitationRefused('ref-b')
- expect(doc().references[1].url).toBe('https://exemple.org/neuf')
- expect(history()).toEqual({ undo: 1, redo: 0 })
- })
-})