Files
faunosteo/apps/app/src/components/editor/findings/FindingCreateForm.tsx
T

286 lines
8.2 KiB
TypeScript

import { useState } from 'react'
import type {
EditCommand,
FindingCategoryKind,
FindingNode,
} 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 {
buildItems,
type FindingItem,
type FindingKind,
} from '@/editor/findings/tree'
import type { IdPrefix } from '@/editor/ids'
import { isBlank, useSheetDocument } from '@/editor/sheetDocument'
import { useEditCommand, type EditCommandApi } from '@/editor/useEditCommand'
import type { Guards } from '@/editor/useEditorNavigation'
import { useT } from '@/i18n/useT'
import { useLocaleStore } from '@/state/localeStore'
export const CATEGORY_KINDS: readonly FindingCategoryKind[] = [
'dysfunction',
'consultation_reason',
'anamnesis',
'custom',
]
export interface PendingFinding {
kind: FindingKind
/** The category or node a node goes under; null for a zone and a category. */
parent: FindingItem | null
}
export interface FindingCreateFormProps {
pending: PendingFinding
readOnly: boolean
guards: Guards
/** `created` is the new element's id, `parent` the element it went under. */
onCreated: (id: string, parent: FindingItem | null) => void
/** A close of the dialog; forced after « Abandonner ». */
onClose: (forced: boolean) => void
}
interface Draft {
fr: string
en: string
kind: string
}
const EMPTY: Draft = { fr: '', en: '', kind: '' }
const sameDraft = (a: Draft, b: Draft) =>
a.fr === b.fr && a.en === b.en && a.kind === b.kind
/** What the core requires before an insert: both names, a zone and a kind for a category. */
function isComplete(draft: Draft, pending: PendingFinding, parent: unknown) {
if (isBlank(draft.fr) || isBlank(draft.en)) return false
return pending.kind !== 'category' || (parent !== null && draft.kind !== '')
}
/** The one `insert`, under a fresh id; the new id, or null when the core refused it. */
function insertNew(
edit: EditCommandApi,
pending: PendingFinding,
parent: FindingItem | null,
draft: Draft,
): string | null {
let createdId = ''
const name = { fr: draft.fr.trim(), en: draft.en.trim() }
const added = edit.runNew('form', PREFIX[pending.kind], (id) => {
createdId = id
return insertCommand({ ...pending, parent }, id, name, draft.kind)
})
return added ? createdId : null
}
/** The form's state and its one `insert` (« Créer »), refused on a missing field. */
function useCreateForm(props: FindingCreateFormProps) {
const edit = useEditCommand()
const zones = useZoneChoice()
const form = useFormDraft(EMPTY, props.guards, sameDraft)
const create = () => {
const { pending } = props
const parent = pending.kind === 'category' ? zones.chosen : pending.parent
if (!isComplete(form.draft, pending, parent)) {
edit.reject('form', 'editor.findings.required')
return
}
const id = insertNew(edit, pending, parent, form.draft)
if (id !== null) props.onCreated(id, parent)
}
return { ...form, zones, create, error: edit.fieldError('form') }
}
/** The kind choice of a category and its two names, as draft fields. */
function CreateFields(props: {
form: ReturnType<typeof useCreateForm>
category: boolean
readOnly: boolean
}) {
const { form, category, readOnly } = props
const t = useT()
const kinds = CATEGORY_KINDS.map((k) => ({
value: k,
label: t(`editor.findings.kind.${k}`),
}))
return (
<div className="grid gap-3 md:grid-cols-2">
{category && <ZoneSelect zones={form.zones} readOnly={readOnly} />}
{category && (
<SelectField
id="finding-new-kind"
label={t('editor.findings.kind')}
value={form.draft.kind}
readOnly={readOnly}
options={[{ value: '', label: t('editor.field.choose') }, ...kinds]}
onCommit={(kind) => form.set({ kind })}
/>
)}
{(['fr', 'en'] as const).map((l) => (
<DraftField
key={l}
id={`finding-new-name-${l}`}
label={t(`editor.general.name_${l}`)}
value={form.draft[l]}
onChange={(value) => form.set({ [l]: value })}
readOnly={readOnly}
/>
))}
</div>
)
}
/**
* Collects what the core requires (names FR/EN, the kind of a category), then one
* `insert`: no element exists with default labels. The fields are a local draft: nothing
* is written before « Créer », a close or a move never creates (R2F-3).
*/
export default function FindingCreateForm(props: FindingCreateFormProps) {
const t = useT()
const form = useCreateForm(props)
const category = props.pending.kind === 'category'
return (
<form
data-draft-form
className="space-y-3"
noValidate
onSubmit={(event) => {
event.preventDefault()
form.create()
}}
>
{props.readOnly && <ReadOnlyNotice />}
{category && form.zones.chosen && <ZoneTitle zone={form.zones.chosen} />}
<CreateFields form={form} category={category} readOnly={props.readOnly} />
{form.error && (
<p role="alert" className="text-sm text-[var(--color-danger-strong)]">
{form.error}
</p>
)}
<FormActions
confirming={form.guard.confirming}
readOnly={props.readOnly}
submitLabel={t('editor.findings.create')}
onCancel={() => props.onClose(props.readOnly)}
onKeepTyping={form.guard.keepTyping}
onDiscard={() => props.onClose(true)}
/>
</form>
)
}
interface ZoneChoice {
zones: readonly FindingItem[]
zoneId: string
setZoneId: (id: string) => void
chosen: FindingItem | null
}
/** The zones to choose from; with exactly one, it is preselected, otherwise nothing is. */
function useZoneChoice(): ZoneChoice {
const doc = useSheetDocument()
const zones = doc ? buildItems(doc).filter((i) => i.kind === 'zone') : []
const [zoneId, setZoneId] = useState(
zones.length === 1 ? zones[0].zoneId : '',
)
const chosen = zones.find((zone) => zone.zoneId === zoneId) ?? null
return { zones, zoneId, setZoneId, chosen }
}
function ZoneSelect({
zones,
readOnly,
}: {
zones: ZoneChoice
readOnly: boolean
}) {
const t = useT()
const locale = useLocaleStore((s) => s.locale)
return (
<SelectField
id="finding-new-zone"
label={t('editor.findings.zone')}
value={zones.zoneId}
readOnly={readOnly}
options={[
{ value: '', label: t('editor.field.choose') },
...zones.zones.map((zone) => ({
value: zone.zoneId,
label: zone.name[locale],
})),
]}
onCommit={zones.setZoneId}
/>
)
}
/** A category lands at zone level: the line under the dialog's title names the zone chosen. */
function ZoneTitle({ zone }: { zone: FindingItem }) {
const t = useT()
const locale = useLocaleStore((s) => s.locale)
return (
<p className="text-sm font-medium">
{t('editor.findings.new.category_in_zone').replace(
'{zone}',
zone.name[locale],
)}
</p>
)
}
const PREFIX: Record<FindingKind, IdPrefix> = {
zone: 'zone',
category: 'fcat',
node: 'node',
}
function insertCommand(
pending: PendingFinding,
id: string,
name: { fr: string; en: string },
kind: string,
): EditCommand {
const parent = pending.parent?.key
if (pending.kind === 'zone') {
return {
op: 'insert',
element: { kind: 'zone', value: { id, name, categories: [] } },
}
}
if (pending.kind === 'category') {
return {
op: 'insert',
parent: pending.parent?.key,
element: {
kind: 'finding_category',
value: {
id,
kind: kind as FindingCategoryKind,
name,
description: {},
reference_ids: [],
review_status: 'to_confirm',
children: [],
},
},
}
}
const node: FindingNode = {
id,
name,
description: {},
requires_vet_referral: false,
reference_ids: [],
review_status: 'to_confirm',
children: [],
}
return {
op: 'insert',
parent,
element: { kind: 'finding_node', value: node },
}
}