@shivaedev/work-board 0.12.0 → 0.13.0

package/src/client/responses/attach.ts

@@ -1,150 +0,0 @@
-import { Effect } from "effect";
-import * as AtomRegistry from "effect/unstable/reactivity/AtomRegistry";
-import { formOwner } from "#client/fieldFeedback.ts";
-import { restoreFocus } from "#client/formFocus.ts";
-import { responseBinding, retainResponseBinding } from "./binding.ts";
-import { responseDraft } from "./draft.ts";
-import { responseFeedback } from "./feedback.ts";
-import { responseFields } from "./fields.ts";
-import { responseForm } from "./form.ts";
-import { responsePreview } from "./preview.ts";
-import { questionnaireControls } from "./questionnaireControls.ts";
-import { submitResponse } from "./submit.ts";
-
-export function attachResponses() {
-	const doc = document.getElementById("doc");
-	if (!doc) {
-		return;
-	}
-	const form = doc.querySelector<HTMLFormElement>("#response-form");
-	if (!form) {
-		return;
-	}
-	const selection = responseBinding(form);
-	if (!form || form.dataset.bound === "true") {
-		return;
-	}
-	form.dataset.bound = "true";
-	const found = responseFields(form);
-	if (!found) {
-		return;
-	}
-	const fields = found;
-	const { author, body, clear, preview, previewButton, status, submit, supersedes, type } = fields;
-	if (status.textContent?.includes("JavaScript is required")) {
-		status.textContent = "Draft ready. Preview the Markdown before recording it.";
-	}
-	const revision = form.dataset.revision ?? "";
-	const questionId = form.dataset.question ?? "";
-	let notice = "";
-	const { drafts, label } = responseDraft(form, (message) => {
-		notice = message;
-		status.textContent = message;
-	});
-	let draft = drafts.current();
-	const owner = formOwner(form);
-	retainResponseBinding(form, owner.release);
-	const controls = questionnaireControls(form, owner.signal);
-	let recovery = controls.restore(draft, revision);
-	if (draft.question && draft.question !== questionId && draft.revision === revision) {
-		notice = "Source moved since this draft. Text is retained and selections cleared; review the source and preview before responding.";
-		status.textContent = notice;
-	}
-	if (supersedes instanceof HTMLSelectElement) {
-		supersedes.value = draft.supersedes ?? "";
-	}
-	author.value = label.read(draft.author);
-	body.value = draft.body;
-	type.value = draft.type;
-	let pending = draft;
-	const { model, sync, valid } = responseForm(form, fields, draft, controls, owner, (values) =>
-		submitResponse(form, status, drafts, pending, values),
-	);
-	const feedback = responseFeedback(form, fields, valid);
-	feedback.show(notice);
-	function save() {
-		const values = sync();
-		label.save(values.author);
-		draft = drafts.update({
-			answers: values.answers,
-			author: values.author,
-			body: values.body,
-			question: draft.question ?? questionId,
-			recovery,
-			revision: draft.revision,
-			supersedes: values.supersedes,
-			type: values.type,
-		});
-		model.change("id", draft.id);
-	}
-	form.addEventListener(
-		"input",
-		() => {
-			save();
-			preview.hidden = true;
-			submit.disabled = true;
-			feedback.show(notice);
-		},
-		{ signal: owner.signal },
-	);
-	previewButton.disabled = false;
-	clear.disabled = false;
-	previewButton.addEventListener(
-		"click",
-		() => {
-			save();
-			if (notice.startsWith("Source ")) {
-				notice = "";
-			}
-			model.change(
-				"id",
-				draft.revision === revision && (!draft.question || draft.question === questionId) ? drafts.current().id : `response.${crypto.randomUUID()}`,
-			);
-			model.change("question", questionId);
-			model.change("revision", revision);
-			draft = drafts.update({ ...model.values.value, recovery });
-			preview.textContent = responsePreview(draft, questionId ?? "", controls.models);
-			preview.hidden = false;
-			const ready = feedback.show(notice, true);
-			submit.disabled = form.dataset.writable !== "true" || !ready;
-		},
-		{ signal: owner.signal },
-	);
-	clear.addEventListener("click", drafts.clear, { signal: owner.signal });
-	form.addEventListener(
-		"submit",
-		async (event) => {
-			event.preventDefault();
-			sync();
-			if (!feedback.show(notice, true)) {
-				feedback.focus();
-				return;
-			}
-			if (submit.disabled || draft.revision !== revision || draft.question !== questionId) {
-				status.textContent = "Preview the current draft before recording. Your text is retained.";
-				return;
-			}
-			submit.disabled = true;
-			previewButton.disabled = true;
-			pending = draft;
-			owner.registry.set(model.submit, undefined);
-			const cleared = await Effect.runPromise(AtomRegistry.getResult(owner.registry, model.submit, { suspendOnWaiting: true })).catch(() => false);
-			if (cleared) {
-				draft = drafts.current();
-				recovery = draft.recovery;
-				if (form.isConnected) {
-					model.receive({ ...model.values.value, answers: undefined, body: "", id: draft.id, supersedes: undefined });
-					model.revert();
-					body.value = model.field("body").value;
-					controls.restore(draft, revision);
-					if (supersedes instanceof HTMLSelectElement) {
-						supersedes.value = "";
-					}
-				}
-			}
-			previewButton.disabled = false;
-		},
-		{ signal: owner.signal },
-	);
-	restoreFocus(form, selection);
-}

package/src/client/responses/binding.ts

@@ -1,16 +0,0 @@
-import { captureFocus } from "#client/formFocus.ts";
-
-const bindings = new WeakMap<HTMLFormElement, { readonly context: string; readonly release: () => void }>();
-function contextOf(form: HTMLFormElement) {
-	return `${form.dataset.question}:${form.dataset.revision}`;
-}
-export function responseBinding(form: HTMLFormElement) {
-	const previous = bindings.get(form);
-	if (previous && previous.context !== contextOf(form)) {
-		previous.release();
-	}
-	return captureFocus(form);
-}
-export function retainResponseBinding(form: HTMLFormElement, release: () => void) {
-	bindings.set(form, { context: contextOf(form), release });
-}

package/src/client/responses/draft.ts

@@ -1,20 +0,0 @@
-import { authorLabel } from "./authorLabel.ts";
-import { draftSession } from "./draftSession.ts";
-
-export function responseDraft(form: HTMLFormElement, report: (message: string) => void) {
-	const workspace = document.documentElement.dataset.workspace;
-	let storage: Storage | undefined;
-	try {
-		storage = window.localStorage;
-	} catch {
-		storage = undefined;
-	}
-	const drafts = draftSession(
-		`${form.dataset.item ?? ""}/${form.dataset.request ?? ""}`,
-		form.dataset.revision ?? "",
-		storage,
-		`work-board:drafts:${workspace}`,
-		report,
-	);
-	return { drafts, label: authorLabel(storage, workspace) };
-}

package/src/client/responses/draftSession.ts

@@ -1,108 +0,0 @@
-import { Clock, Effect } from "effect";
-import { DRAFT_AGE, type Draft, encodeDrafts, readDrafts } from "./drafts.ts";
-
-const states = new Map<string, Draft>();
-export function draftSession(
-	key: string,
-	revision: string,
-	storage: Storage | undefined,
-	storageKey: string,
-	report: (message: string) => void,
-	prefix = "response",
-) {
-	const stateKey = `${JSON.stringify(storageKey)}:${key}`;
-	function local() {
-		if (!storage) {
-			throw new Error("Draft storage unavailable");
-		}
-		return storage;
-	}
-	let blocked = false;
-	let drafts: Record<string, Draft> = {};
-	try {
-		const stored = readDrafts(local().getItem(storageKey), Effect.runSync(Clock.currentTimeMillis));
-		drafts = stored.drafts;
-		if (stored.expired) {
-			report("Expired drafts were cleared after 30 days. Saved responses are unaffected.");
-		}
-		local().setItem(storageKey, encodeDrafts(drafts));
-	} catch {
-		blocked = true;
-		report("Draft history is unavailable or malformed. Keep a copy; edits remain in this window.");
-	}
-	const memory = states.get(stateKey);
-	if (memory && Effect.runSync(Clock.currentTimeMillis) - memory.updatedAt >= DRAFT_AGE) {
-		states.delete(stateKey);
-		report("A window draft expired after 30 days. Saved responses are unaffected.");
-	}
-	let current = states.get(stateKey)
-		?? drafts[key] ?? {
-			author: "",
-			body: "",
-			id: `${prefix}.${crypto.randomUUID()}`,
-			revision,
-			type: "answer",
-			updatedAt: Effect.runSync(Clock.currentTimeMillis),
-		};
-	if (current.revision !== revision) {
-		report("Source changed since this draft. Your text is retained; review the new source and preview to bind it to this revision.");
-	}
-	function update(patch: Partial<Draft>) {
-		current = { ...(states.get(stateKey) ?? current), ...patch, updatedAt: Effect.runSync(Clock.currentTimeMillis) };
-		states.set(stateKey, current);
-		try {
-			if (blocked) {
-				throw new Error("Unknown draft history");
-			}
-			const latest = readDrafts(local().getItem(storageKey), Effect.runSync(Clock.currentTimeMillis)).drafts;
-			local().setItem(storageKey, encodeDrafts({ ...latest, [key]: current }));
-		} catch {
-			report("Draft could not be persisted (storage full or unavailable). Keep a copy; your text remains in this window.");
-		}
-		return current;
-	}
-	function clear() {
-		try {
-			local().removeItem(storageKey);
-			blocked = false;
-			for (const storedKey of states.keys()) {
-				if (storedKey.startsWith(`${JSON.stringify(storageKey)}:`)) {
-					states.delete(storedKey);
-				}
-			}
-			report("Workspace drafts cleared. Saved responses are unchanged; this visible text remains until you navigate away.");
-		} catch {
-			report("Draft storage could not be cleared.");
-		}
-	}
-	function saved(pending: Draft) {
-		if (states.get(stateKey) !== pending) {
-			const live = states.get(stateKey);
-			if (live?.id === pending.id) {
-				update({ id: `${prefix}.${crypto.randomUUID()}` });
-			}
-			return false;
-		}
-		states.delete(stateKey);
-		try {
-			const latest = readDrafts(local().getItem(storageKey), Effect.runSync(Clock.currentTimeMillis)).drafts;
-			if (latest[key]?.id === pending.id) {
-				delete latest[key];
-			}
-			local().setItem(storageKey, encodeDrafts(latest));
-		} catch {
-			report("Saved response confirmed, but its browser draft could not be cleared.");
-		}
-		current = {
-			...current,
-			answers: undefined,
-			body: "",
-			id: `${prefix}.${crypto.randomUUID()}`,
-			recovery: undefined,
-			supersedes: undefined,
-			updatedAt: Effect.runSync(Clock.currentTimeMillis),
-		};
-		return true;
-	}
-	return { clear, current: () => current, saved, update };
-}

package/src/client/responses/drafts.ts

@@ -1,82 +0,0 @@
-import { Schema } from "effect";
-import { Answers, type PromptAnswer } from "#browser/responses/schema.ts";
-import { Identity } from "#path/Identity.ts";
-
-export const DRAFT_BYTES = 2 * 1024 * 1024;
-export const DRAFT_AGE = 30 * 24 * 60 * 60 * 1000;
-export interface Draft {
-	readonly answers?: readonly PromptAnswer[] | undefined;
-	readonly author: string;
-	readonly body: string;
-	readonly id: string;
-	readonly question?: string | undefined;
-	readonly recovery?: string | undefined;
-	readonly revision: string;
-	readonly supersedes?: string | undefined;
-	readonly type: string;
-	readonly updatedAt: number;
-}
-function extraFields(entry: object) {
-	return {
-		...("question" in entry ? { question: Schema.decodeUnknownSync(Identity)(entry.question) } : {}),
-		...("recovery" in entry ? { recovery: Schema.decodeUnknownSync(Schema.String)(entry.recovery) } : {}),
-		...("answers" in entry ? { answers: Schema.decodeUnknownSync(Answers, { onExcessProperty: "error" })(entry.answers) } : {}),
-		...("supersedes" in entry ? { supersedes: Schema.decodeUnknownSync(Identity)(entry.supersedes) } : {}),
-	};
-}
-export function readDrafts(raw: string | null, now: number): { drafts: Record<string, Draft>; expired: boolean } {
-	if (raw === null) {
-		return { drafts: {}, expired: false };
-	}
-	if (new TextEncoder().encode(raw).length > DRAFT_BYTES) {
-		throw new Error("Draft storage exceeds the workspace limit.");
-	}
-	const value: unknown = JSON.parse(raw);
-	if (typeof value !== "object" || value === null || Array.isArray(value)) {
-		throw new Error("Draft storage is malformed.");
-	}
-	const drafts: Record<string, Draft> = {};
-	let expired = false;
-	for (const [key, entry] of Object.entries(value)) {
-		if (
-			typeof entry !== "object"
-			|| entry === null
-			|| !("author" in entry)
-			|| !("body" in entry)
-			|| !("id" in entry)
-			|| !("revision" in entry)
-			|| !("type" in entry)
-			|| !("updatedAt" in entry)
-			|| typeof entry.author !== "string"
-			|| typeof entry.body !== "string"
-			|| typeof entry.id !== "string"
-			|| typeof entry.revision !== "string"
-			|| (entry.type !== "answer" && entry.type !== "clarify" && entry.type !== "not_now")
-			|| typeof entry.updatedAt !== "number"
-			|| !Number.isFinite(entry.updatedAt)
-		) {
-			throw new Error("Draft storage is malformed.");
-		}
-		if (entry.updatedAt > now || now - entry.updatedAt >= DRAFT_AGE) {
-			expired = true;
-			continue;
-		}
-		drafts[key] = {
-			...extraFields(entry),
-			author: entry.author,
-			body: entry.body,
-			id: entry.id,
-			revision: entry.revision,
-			type: entry.type,
-			updatedAt: entry.updatedAt,
-		};
-	}
-	return { drafts, expired };
-}
-export function encodeDrafts(drafts: Readonly<Record<string, Draft>>): string {
-	const value = JSON.stringify(drafts);
-	if (new TextEncoder().encode(value).length > DRAFT_BYTES) {
-		throw new Error("Draft storage is full. Copy this draft before clearing workspace drafts.");
-	}
-	return value;
-}

package/src/client/responses/feedback.ts

@@ -1,81 +0,0 @@
-import type { responseFields } from "./fields.ts";
-
-type Control = HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;
-
-function promptName(prompt: HTMLFieldSetElement) {
-	return prompt.querySelector("legend")?.textContent ?? "Question";
-}
-function unanswered(prompt: HTMLFieldSetElement) {
-	return !(prompt.querySelector("input:checked") || prompt.querySelector<HTMLTextAreaElement>("textarea")?.value.trim());
-}
-function errorFor(control: Control, author: HTMLInputElement, missing: readonly HTMLFieldSetElement[]) {
-	if (control === author && !author.value.trim()) {
-		return "Add your local author label.";
-	}
-	const prompt = control.closest("fieldset");
-	if (prompt && missing.includes(prompt)) {
-		return `Unanswered: ${promptName(prompt)}. Choose an option or answer in your own words.`;
-	}
-	return control.validationMessage;
-}
-function displayError(control: Control, message: HTMLElement, error: string) {
-	message.textContent = error;
-	message.hidden = !error;
-	control.setAttribute("aria-invalid", String(Boolean(error)));
-	if (error) {
-		control.closest("details")?.setAttribute("open", "");
-	}
-}
-function messageFor(control: Control, index: number) {
-	const existing = control.nextElementSibling;
-	const message = existing instanceof HTMLElement && existing.classList.contains("response-field-error") ? existing : document.createElement("span");
-	message.id = `response-error-${index}`;
-	message.className = "response-field-error";
-	message.hidden = true;
-	control.after(message);
-	control.setAttribute("aria-describedby", message.id);
-	return { control, message };
-}
-function readyMessage(decoded: boolean, previewed: boolean) {
-	if (!decoded) {
-		return "This draft is invalid. Review the response fields before recording.";
-	}
-	return previewed ? "Preview ready. Record this response when you are ready." : "Draft ready. Preview the Markdown before recording it.";
-}
-
-export function responseFeedback(form: HTMLFormElement, fields: NonNullable<ReturnType<typeof responseFields>>, valid: () => boolean) {
-	const { author, body, status, supersedes, type } = fields;
-	const prompts = [...form.querySelectorAll<HTMLFieldSetElement>("fieldset[data-prompt]")];
-	const controls: readonly Control[] = [
-		author,
-		body,
-		type,
-		...(supersedes instanceof HTMLSelectElement ? [supersedes] : []),
-		...prompts.flatMap((prompt) => [...prompt.querySelectorAll<HTMLTextAreaElement>("textarea")]),
-	];
-	const messages = controls.map(messageFor);
-	function show(notice: string, previewed = false) {
-		const decoded = valid();
-		const missing = type.value === "answer" ? prompts.filter(unanswered) : [];
-		for (const { control, message } of messages) {
-			displayError(control, message, errorFor(control, author, missing));
-		}
-		const errors = messages.filter(({ message }) => !message.hidden);
-		const summary = [
-			author.value.trim() ? "" : "Add your local author label.",
-			missing.length > 0 ? `Unanswered prompts: ${missing.map(promptName).join("; ")}.` : "",
-			...errors.filter(({ control }) => control !== author && !control.closest("fieldset")).map(({ message }) => message.textContent),
-		]
-			.filter(Boolean)
-			.join(" ");
-		if (form.dataset.writable === "true" && status.dataset.outcome !== "pending") {
-			delete status.dataset.outcome;
-			status.textContent = [notice, summary || readyMessage(decoded, previewed)].filter(Boolean).join(" ");
-		}
-		return decoded && errors.length === 0;
-	}
-	function focus() {
-		messages.find(({ message }) => !message.hidden)?.control.focus();
-	}
-	return { focus, show };
-}

package/src/client/responses/fields.ts

@@ -1,26 +0,0 @@
-export function responseFields(form: HTMLFormElement) {
-	const status = form.querySelector<HTMLParagraphElement>("#response-status");
-	const author = form.elements.namedItem("author");
-	const body = form.elements.namedItem("body");
-	const type = form.elements.namedItem("type");
-	const supersedes = form.elements.namedItem("supersedes");
-	const submit = form.querySelector<HTMLButtonElement>("#response-submit");
-	const preview = form.querySelector<HTMLPreElement>("#response-preview-content");
-	const clear = form.querySelector<HTMLButtonElement>("#response-clear");
-	const previewButton = form.querySelector<HTMLButtonElement>("#response-preview");
-	if (
-		!(
-			status
-			&& author instanceof HTMLInputElement
-			&& body instanceof HTMLTextAreaElement
-			&& type instanceof HTMLSelectElement
-			&& submit
-			&& preview
-			&& clear
-			&& previewButton
-		)
-	) {
-		return undefined;
-	}
-	return { author, body, clear, preview, previewButton, status, submit, supersedes, type };
-}

package/src/client/responses/form.ts

@@ -1,58 +0,0 @@
-import { Effect, Layer } from "effect";
-import * as Atom from "effect/unstable/reactivity/Atom";
-import { make } from "@shivaedev/effect-form/form.ts";
-import { fieldFeedback, type formOwner } from "#client/fieldFeedback.ts";
-import type { Draft } from "./drafts.ts";
-import type { responseFields } from "./fields.ts";
-import { type ResponseSubmission, responseFormSchema } from "./formSchema.ts";
-import type { questionnaireControls } from "./questionnaireControls.ts";
-
-export function responseForm(
-	form: HTMLFormElement,
-	fields: NonNullable<ReturnType<typeof responseFields>>,
-	draft: Draft,
-	controls: ReturnType<typeof questionnaireControls>,
-	owner: ReturnType<typeof formOwner>,
-	onSubmit: (values: ResponseSubmission) => Promise<boolean>,
-) {
-	const { author, body, supersedes, type } = fields;
-	const questionId = form.dataset.question ?? "";
-	const model = make(responseFormSchema(controls.models.length > 0), {
-		initialValues: {
-			answers: controls.read(),
-			author: author.value,
-			body: body.value,
-			id: draft.id,
-			question: questionId,
-			revision: draft.revision,
-			supersedes: draft.supersedes,
-			type: type.value,
-		},
-		onSubmit: (values) => Effect.tryPromise({ catch: (error) => error, try: () => onSubmit(values) }),
-		runtime: Atom.runtime(Layer.empty),
-	});
-	const valid = fieldFeedback(
-		model,
-		owner,
-		[
-			{ control: author, name: "author" },
-			{ control: body, name: "body" },
-			{ control: type, name: "type" },
-			{ control: supersedes instanceof HTMLSelectElement ? supersedes : undefined, name: "supersedes" },
-			{ name: "answers" },
-			{ name: "id" },
-			{ name: "question" },
-			{ name: "revision" },
-		],
-		[...form.querySelectorAll<HTMLTextAreaElement>("[data-answer-text]")].map((control, index) => ({ control, path: ["answers", index, "text"] })),
-	);
-	function sync() {
-		model.change("author", fields.author.value);
-		model.change("body", fields.body.value);
-		model.change("type", fields.type.value);
-		model.change("answers", controls.read());
-		model.change("supersedes", supersedes instanceof HTMLSelectElement ? supersedes.value || undefined : undefined);
-		return model.values.value;
-	}
-	return { model, sync, valid };
-}

package/src/client/responses/questionnaireControls.ts

@@ -1,94 +0,0 @@
-import type { Prompt } from "#browser/responses/Prompt.ts";
-import type { PromptAnswer } from "#browser/responses/schema.ts";
-import type { Draft } from "./drafts.ts";
-
-function restoreAnswers(fields: readonly HTMLFieldSetElement[], draft: Draft, same: boolean) {
-	for (const field of fields) {
-		const answer = draft.answers?.find((entry) => entry.prompt === field.dataset.prompt);
-		for (const input of field.querySelectorAll<HTMLInputElement>("input")) {
-			input.checked = same && (answer?.selected.includes(input.value) ?? false);
-		}
-		const text = field.querySelector<HTMLTextAreaElement>("textarea");
-		if (text) {
-			text.value = answer?.text ?? "";
-		}
-	}
-}
-export function questionnaireControls(form: HTMLFormElement, signal: AbortSignal) {
-	function modeOf(field: HTMLFieldSetElement) {
-		if (field.dataset.mode === "text") {
-			return "text";
-		}
-		return field.dataset.mode === "many" ? "many" : "one";
-	}
-	const fields = [...form.querySelectorAll<HTMLFieldSetElement>("fieldset[data-prompt]")];
-	function syncChoices() {
-		for (const button of form.querySelectorAll<HTMLButtonElement>("button[data-choice]")) {
-			const input = form.querySelector<HTMLInputElement>(`input[value="${button.dataset.choice}"]`);
-			button.setAttribute("aria-pressed", String(input?.checked ?? false));
-		}
-	}
-	form.addEventListener(
-		"click",
-		(event) => {
-			const button = event.target instanceof Element ? event.target.closest<HTMLButtonElement>("button[data-choice]") : null;
-			if (!button) {
-				return;
-			}
-			const input = form.querySelector<HTMLInputElement>(`input[value="${button.dataset.choice}"]`);
-			if (input) {
-				input.checked = true;
-				syncChoices();
-				input.dispatchEvent(new Event("input", { bubbles: true }));
-			}
-		},
-		{ signal },
-	);
-	form.addEventListener("input", syncChoices, { signal });
-	const models: Prompt[] = fields.map((field) => ({
-		id: field.dataset.prompt ?? "",
-		mode: modeOf(field),
-		options: [...field.querySelectorAll<HTMLInputElement>("input[data-option-source]")].map((input) => ({
-			id: input.value,
-			source: input.dataset.optionSource ?? "",
-		})),
-		source: field.dataset.source ?? "",
-	}));
-	function read(): readonly PromptAnswer[] | undefined {
-		return fields.length === 0
-			? undefined
-			: fields.map((field) => ({
-					prompt: field.dataset.prompt ?? "",
-					selected: [...field.querySelectorAll<HTMLInputElement>("input:checked")].map((input) => input.value),
-					text: field.querySelector<HTMLTextAreaElement>("textarea")?.value ?? "",
-				}));
-	}
-	function restore(draft: Draft, revision: string) {
-		const same = draft.revision === revision && (draft.question === undefined || draft.question === form.dataset.question);
-		restoreAnswers(fields, draft, same);
-		syncChoices();
-		const recovery = form.querySelector<HTMLPreElement>("#response-draft-recovery");
-		const retained =
-			!same && draft.answers
-				? `Earlier template answers (selections cleared; review before choosing again):\n${JSON.stringify(draft.answers, null, 2)}\n${draft.recovery ?? ""}`
-				: draft.recovery;
-		if (recovery) {
-			recovery.textContent = retained ?? "";
-			recovery.hidden = !retained;
-		}
-		return retained;
-	}
-	for (const field of fields) {
-		field.querySelector("[data-clear-choices]")?.addEventListener(
-			"click",
-			() => {
-				for (const input of field.querySelectorAll<HTMLInputElement>("input")) {
-					input.checked = false;
-				}
-				form.dispatchEvent(new Event("input", { bubbles: true }));
-			},
-			{ signal },
-		);
-	}
-	return { models, read, restore };
-}

package/src/client/responses/setup.ts

@@ -1,6 +0,0 @@
-import { attachResponses } from "./attach.ts";
-export function setupResponses() {
-	document.addEventListener("board-page", attachResponses);
-	window.addEventListener("pageshow", attachResponses);
-	attachResponses();
-}