// --------------------------------------------------------------------------- // forms / FormPublic.tsx — ⭐ wave-23 item 8 (contract W23-C9). // // The page an ANONYMOUS person lands on at `#/form/`. E mounts it in the // Shell BEFORE the auth wall (wiring W23-W2); everything below assumes there is // no session, no workspace, no nav and no viewer. // // ⛔ IT IMPORTS NOTHING FROM `customer-grid/**`, AND THAT IS A REQUIREMENT, NOT // A PREFERENCE. The grid bundle drags glide-data-grid — hundreds of kilobytes // of canvas table — into whatever chunk touches it, and this page is the one // surface in the product that a stranger loads cold, once, probably on a phone, // probably on mobile data, to type four answers. One convenience import from // `types.ts` would put the whole spreadsheet engine on that wire. So the field // vocabulary below is DECLARED HERE as plain strings rather than imported: the // server sends `type` as a string and this page renders a control per string, // which is the same "no client union over a server vocabulary" rule the rest of // the wave follows, arriving here for a second reason. // // ⚠ Styling reuses `.lpf-*` rules in the D REGION of index.css — the shell's // stylesheet is one file and already loaded; a second stylesheet for one page // would be a second copy of the tokens. // --------------------------------------------------------------------------- import { useEffect, useRef, useState } from "react"; import { Brand } from "../shell/Brand"; /** One field, exactly as `routes_forms._public_form` builds it. Nothing here is * optional-because-maybe: every key below is one the server always sends, and * the three that are conditional say so. */ interface FormField { key: string; label: string; /** The server's own word. Deliberately `string`, not a union — an unknown * type lands on the text input, which is the safe direction: a person can * always type an answer, and a control this page has never heard of would * otherwise render as nothing at all. */ type: string; required: boolean; options?: string[]; max?: number; secret?: boolean; hint?: string; } interface FormSpec { title: string; desc: string; submitLabel: string; fields: FormField[]; /** The honeypot's field name — planted, never shown. Server-named so the two * halves cannot drift into a trap nobody checks. */ honeypot: string; kind?: string; singleUse?: boolean; } type Phase = "loading" | "ready" | "sent" | "gone" | "failed" | "unavailable"; const LONG_TEXT_MIN = 0; // every text field gets a textarea when it is the only one export default function FormPublic({ token }: { token: string }) { // Changing capabilities unmounts the old inputs and destroys all typed values. return ; } function PublicForm({ token }: { token: string }) { const [spec, setSpec] = useState(null); const [phase, setPhase] = useState("loading"); const [values, setValues] = useState>({}); const [error, setError] = useState(""); const [busy, setBusy] = useState(false); const post = useRef(null); useEffect(() => { let live = true; const controller = new AbortController(); setPhase("loading"); setSpec(null); setValues({}); setError(""); fetch(`/api/v1/forms/${encodeURIComponent(token)}`, { signal: controller.signal }) .then((r) => (r.ok ? r.json() : Promise.reject(new Error(String(r.status))))) .then((data: FormSpec) => { if (!live) return; setSpec(data); setPhase("ready"); }) // Invalid capabilities share one expired state; a transport failure proves no expiry. .catch((failure: unknown) => { if (live) setPhase(failure instanceof Error && failure.message === "403" ? "gone" : "unavailable"); }); return () => { live = false; controller.abort(); post.current?.abort(); }; }, [token]); const set = (key: string, v: string) => setValues((prev) => ({ ...prev, [key]: v })); const submit = (event: React.FormEvent) => { event.preventDefault(); if (busy) return; setBusy(true); setError(""); const controller = new AbortController(); post.current = controller; fetch(`/api/v1/forms/${encodeURIComponent(token)}`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ values }), signal: controller.signal, }) .then(async (r) => { if (controller.signal.aborted) return; if (r.ok) { setValues({}); setPhase("sent"); return; } const body = await r.json().catch(() => null); if (controller.signal.aborted) return; if (body?.error?.code === "data_input_frozen") { setError(String(body.error.message)); } else if (!spec?.singleUse) { setError(String(body?.error?.message || "That could not be sent; check your answers and try again.")); } else if (r.status === 403) { setPhase("gone"); } else if (body?.error?.code === "setup_write_failed") { setPhase("failed"); } else { setError(r.status === 400 ? "Invalid fields" : r.status === 429 ? "Busy" : "Not sent"); } }) .catch(() => { if (!controller.signal.aborted) setError(spec?.singleUse ? "Not sent" : "That could not be sent; check your connection and try again."); }) .finally(() => { if (controller.signal.aborted) return; if (spec?.singleUse) setValues({}); setBusy(false); post.current = null; }); }; if (phase === "loading") return (
); if (phase === "gone" || phase === "failed" || phase === "unavailable") return (

{phase === "failed" ? "Save failed" : phase === "unavailable" ? "Unavailable" : "Expired"}

); if (phase === "sent") return (

{spec?.singleUse ? "Saved" : "Submitted"}

{!spec?.singleUse && ( )}
); if (!spec) return null; return (

{spec.title || "Form"}

{!spec.singleUse && spec.desc &&

{spec.desc}

} {spec.fields.map((f) => ( ))} {/* ⛔ THE HONEYPOT. Off-screen rather than `display:none` — several bot frameworks skip hidden inputs on purpose, and a trap they know to skip is not a trap. `tabIndex={-1}` and `aria-hidden` keep it away from a keyboard user and a screen reader alike, and `autoComplete="off"` stops a browser filling it for a real person, which would silently drop their submission. */} set(spec.honeypot, e.target.value)} tabIndex={-1} autoComplete="off" aria-hidden /> {error &&

{error}

}
); } /** One control per server type string. An unrecognised type falls through to text — see the * `FormField.type` note: a stranger can always type an answer, and a blank where a control * should be is the one failure they cannot work around. */ function FieldControl({ field, value, onChange, disabled, }: { field: FormField; value: string; onChange: (key: string, v: string) => void; disabled: boolean; }) { const common = { className: "lpf-input", value, required: field.required, disabled, title: field.hint, onChange: (e: { target: { value: string } }) => onChange(field.key, e.target.value), }; if (field.secret || field.type === "password") return ; switch (field.type) { case "checkbox": return ( onChange(field.key, e.target.checked ? "1" : "")} /> ); case "select": case "status": return ( ` with no blank member has its first choice pre-selected, so an untouched optional field silently submits a value the person never picked. */} {(field.options ?? []).map((o) => ( ))} ); case "int": case "currency": case "pct": case "rating": return ; case "date": // ⚠ `type="date"` submits ISO (`YYYY-MM-DD`) whatever the browser DISPLAYS, which is // exactly what the server's refuse-never-coerce date check demands. A text input here // would send whatever the locale suggested and be refused on half the planet. return ; case "email": return ; case "phone": return ; case "url": return ; case "text": return (