Files
plan2code/src/web-console/public/screens/cards.js
T

1575 lines
61 KiB
JavaScript
Raw Normal View History

// Plan2Code Web Console - question cards: every kind, the pager, settled and in-flight records; defines only.
import { hooks, page, redraw, stage, saveNow, setDraft } from "../state.js";
import {
openItems,
awaitingReply,
finish,
myTurn,
isOpen,
submittedInFlight,
agentWorking,
workingMs,
patience,
WORKING_GRACE_MS,
topics,
byId,
docs,
isGitBoard,
} from "../selectors.js";
import {
lastOpenCard,
nextOpenAfter,
sentAnswer,
recordedAnswer,
answerLines,
threadWho,
threadText,
noteAwaiting,
submittedAwaiting,
showKey,
choiceAnswer,
suggestionFrom,
verdictText,
handoffText,
finishPaused,
} from "../answers.js";
import { el, md } from "../render.js";
import {
sentAttachments,
incomingFiles,
attachFiles,
attachRow,
noteImages,
attachTray,
} from "../uploads.js";
import { attachMentions } from "../mention-box.js";
import { TEMPLATE_WORKFLOWS, templatesFor, templateSwap } from "../starters.js";
import { looks } from "../looks.js";
const $ = (id) => document.getElementById(id);
// The question card currently on screen, so the quiet staging path can find its
// border and pill again without a DOM search. Replaced on every renderCard.
let cardMarks = null;
export function markFor(item) {
// On a finished session an open item is frozen, not waiting: its send went
// and can no longer be added to, or it was never answered and never can be.
if (isOpen(item) && finish()) {
return recordedAnswer(item)
? { glyph: "✓", cls: "done", label: "sent" }
: { glyph: "○", cls: "open", label: "left unanswered" };
}
if (page.local.staged[item.id]) return { glyph: "●", cls: "staged", label: "ready to send" };
if (isOpen(item) && ((page.local.sent && page.local.sent[item.id]) || submittedInFlight(item)))
return { glyph: "◐", cls: "staged", label: "sent, waiting for Plan2Code" };
if (!isOpen(item)) return { glyph: "✓", cls: "done", label: "answered" };
return { glyph: "○", cls: "open", label: "waiting for you" };
}
// The session's own ending, as a page of its own at the top of the rail.
// A pause and a finish share the screen -- the hand-off card -- but not the
// name: "paused" is the word the stop playbook asks for in the headline, and
// it is the word the person was told to expect.
export function renderEndItem(fin) {
const paused = finishPaused(fin);
const box = el("div", "rail-group rail-end");
const b = el("button", "rail-item");
b.type = "button";
b.setAttribute("aria-current", String(page.view === "end"));
const mark = el("span", "rail-mark " + (paused ? "staged" : "done"), paused ? "❚❚" : "✓");
mark.title = paused ? "session paused" : "session ended";
b.appendChild(mark);
b.appendChild(el("span", "rail-end-label", paused ? "Paused" : "Session ended"));
b.addEventListener("click", () => {
page.view = "end";
redraw();
$("main").focus();
});
box.appendChild(b);
return box;
}
// A card that scrolls its own contents fades out at the bottom edge while
// there is more below: a finished screen's buttons, a long question's last
// options, otherwise sit past the fold looking like the card simply ends.
export function markMore() {
for (const card of $("main").querySelectorAll(":scope > .card")) {
card.classList.toggle("has-more", card.scrollHeight - card.scrollTop - card.clientHeight > 4);
}
}
// One answer box per card grows into the card's free height: the text
// question's box, else a picked "Something else" box, else the card's note.
// Every other box keeps its ordinary height, and the notes panel beside the
// card is never a candidate.
function markGrowBox(card) {
if (!card) return;
const id = card.dataset.item;
const areas = [...card.querySelectorAll("textarea")];
// Not over the git board: the column there flows card and board at natural
// height, so there is no free height for a box to grow into.
const box = isGitBoard()
? null
: areas.find((t) => t.id === "text-" + id) ||
card.querySelector(".option.is-other.is-picked textarea.other-text") ||
areas.find((t) => t.id === "note-" + id);
// Only a box that stops being the one gives its fill back, so a keystroke
// that re-marks the same box leaves its height alone.
for (const n of areas) {
if (n === box || !n.classList.contains("grow")) continue;
n.classList.remove("grow");
n.style.minHeight = "";
}
if (box) box.classList.add("grow");
card.classList.toggle("has-grow", Boolean(box));
}
// The height the card's contents would take if nothing stretched them. Not
// scrollHeight: that never reads less than the card's own height, so a box
// shorter than the fill could never be told how much room it has.
function naturalHeight(card) {
const last = card.lastElementChild;
if (!last) return 0;
const top = card.getBoundingClientRect().top + card.clientTop;
return (
last.getBoundingClientRect().bottom -
top +
card.scrollTop +
parseFloat(getComputedStyle(last).marginBottom || "0") +
parseFloat(getComputedStyle(card).paddingBottom || "0")
);
}
// The fill is written as the box's min-height, which is what lets the drag
// handle only ever make it taller: resize: vertical alone cannot hold a floor
// that moves with the window. Below a 160px fill the card scrolls instead.
export function fitGrowBox() {
const box = $("main").querySelector(":scope > .card.has-grow textarea.grow");
if (!box) return;
const card = box.closest(".card");
const other = naturalHeight(card) - box.offsetHeight;
const fill = Math.max(160, Math.floor(card.clientHeight - other));
const now = parseFloat(box.style.minHeight) || 0;
if (Math.abs(now - fill) > 1) box.style.minHeight = fill + "px";
}
// It watches the column, not the box. The box growing changes what the card
// scrolls, never the column's size, so resizing the box here can never set
// off another callback: the loop a box-watching observer would feed.
const growObserver = typeof ResizeObserver === "function" ? new ResizeObserver(() => (fitGrowBox(), markMore())) : null;
// To one question, at its top, with focus on the column.
function goToItem(id) {
page.selected = id;
page.view = "questions";
redraw();
const m = $("main");
m.focus();
m.scrollTop = 0;
}
// "Skip this one": staged as skipped, "Skipped" for a beat, then on to the
// next card that still needs the person, or to Send when this was the last.
// Anything the person does first (a click, a key) cancels the move.
let skipTimer = null;
function cancelSkipMove() {
if (!skipTimer) return;
clearTimeout(skipTimer);
skipTimer = null;
page.local.skipFlash = null;
}
function skipAndMoveOn(id) {
cancelSkipMove();
page.local.skipFlash = id;
// A note already typed goes along: skipping the question is not retracting
// the comment. Dropping it would leave the text in the box but out of the
// send, which looks kept and is not.
const cur = page.local.staged[id];
stage(id, { type: "skip", skipped: true, ...(cur && cur.text ? { text: cur.text } : {}) });
skipTimer = setTimeout(() => {
skipTimer = null;
page.local.skipFlash = null;
const openIds = openItems().map((i) => i.id);
const sent = Object.fromEntries(awaitingReply().map((i) => [i.id, true]));
const next = lastOpenCard(openIds, page.local.staged, sent, id) ? null : nextOpenAfter(openIds, page.local.staged, sent, id);
if (next) return goToItem(next);
redraw();
$("btn-send").focus();
}, 250);
}
// Previous / next across the questions still waiting.
//
// The left rail already navigates, but it is a list of everything and it reads
// as a table of contents rather than as a way through. Someone working down
// three open questions should not have to aim at a 13px row to reach the next
// one. Settled questions are deliberately not in this walk: they are reference,
// not work, and the rail is where you go back to them.
export function buildPager(item) {
// Once the session has ended nothing open can be sent, so a way "back to
// what is waiting" would lead somewhere that goes nowhere.
if (finish()) return null;
// Theirs to answer, not just unanswered by the agent: a sent question
// waiting on the other end is not a place this walk should stop.
const open = myTurn();
if (!open.length) return null;
const go = (target) => goToItem(target.id);
const row = el("nav", "pager");
row.setAttribute("aria-label", "Move between the questions waiting");
const at = open.findIndex((i) => i.id === item.id);
if (at === -1) {
// Reading something already settled. The only move that means anything
// here is back to the work.
const b = el("button", "btn small pager-btn next");
b.type = "button";
const box = el("span", "pager-label");
box.appendChild(el("span", "pager-kicker", "Back to what is waiting"));
box.appendChild(el("span", "pager-title", open[0].title));
b.appendChild(box);
b.appendChild(el("span", "pager-arrow", "→"));
b.addEventListener("click", () => go(open[0]));
row.className = "pager one";
row.appendChild(b);
return row;
}
if (open.length < 2) return null;
// Once this question is answered, the step is the next unanswered one, not
// Send. Send lighting up the moment a single answer is staged pulls people
// into sending one question at a time, which is three round trips where the
// workflow wanted one. So the emphasis moves to whichever neighbour still
// needs them, and Send goes quiet until nothing does.
const here = Boolean(page.local.staged[item.id]);
const nextT = open[at + 1];
const prevT = open[at - 1];
// "Still needs them" is not the same as "not staged": a question already sent
// is locked and waiting on the agent, so pointing at it as the step would
// walk someone into a card they cannot act on.
const needs = (t) => Boolean(t && !page.local.staged[t.id] && !(page.local.sent && page.local.sent[t.id]));
const leadNext = here && needs(nextT);
const leadPrev = here && !leadNext && needs(prevT);
// An end of the queue is an empty slot, not a disabled button. A greyed
// "Previous" pointing at nothing is a control that exists only to say no.
const mk = (target, back, lead) => {
if (!target) return el("span", "pager-slot");
const b = el(
"button",
"btn small pager-btn " + (back ? "prev" : "next") + (lead ? " lead" : " ghost")
);
b.type = "button";
const arrow = el("span", "pager-arrow", back ? "←" : "→");
const box = el("span", "pager-label");
box.appendChild(el("span", "pager-kicker", back ? "Previous" : "Next"));
box.appendChild(el("span", "pager-title", target.title));
if (back) {
b.appendChild(arrow);
b.appendChild(box);
} else {
b.appendChild(box);
b.appendChild(arrow);
}
b.addEventListener("click", () => go(target));
return b;
};
row.appendChild(mk(prevT, true, leadPrev));
row.appendChild(el("span", "pager-count", `${at + 1} of ${open.length} waiting`));
row.appendChild(mk(nextT, false, leadNext));
return row;
}
// A notice is context for the question it sits beside, so it lives inside the
// one card rather than as a second one under it.
export function renderNotice(item) {
const box = el("div", "card-note card-extra");
box.appendChild(el("p", "note-kicker", "Note"));
box.appendChild(el("h3", "note-title", item.title));
box.appendChild(md(item.body, "md"));
return box;
}
// An ANSWER that has been sent but not yet dealt with. Its controls are locked:
// the agent is mid-turn on exactly this question, so a change made now reaches
// nobody, and the change would then be deleted by the next state update.
//
// A send carrying only a note is not that. Someone who asks a question about
// the question before answering it has not answered it, and locking the form
// there leaves an open question that cannot be answered at all. The note is
// still shown as on its way, by the "Sent" pill and the rail mark.
function inFlightFor(item) {
if (!isOpen(item) || finish()) return null;
const sent = page.local.sent && page.local.sent[item.id];
if (sentAnswer(sent)) return sent;
// The send this tab no longer remembers (a reload, a resumed session, a
// second tab) or one the agent took without settling the question: the
// server's copy on the item is the same fact either way.
const sub = submittedInFlight(item);
return sub ? { value: sub, summary: "" } : null;
}
export function renderCard(item) {
const staged = page.local.staged[item.id];
const flight = inFlightFor(item);
const card = el(
"article",
"card question" +
(!isOpen(item) || finish() ? " is-answered" : staged ? " is-staged" : "") +
(flight ? " is-inflight" : "")
);
// Which question this card is for, so a render can tell whether the card it
// is replacing is the same one (keep the scroll) or a different one (start
// at the top).
card.dataset.item = item.id;
const kicker = el("p", "card-kicker");
fillKicker(kicker, item);
card.appendChild(kicker);
// Held so the quiet staging path can repaint the border and the pill without
// rebuilding the card, which would take the textarea being typed into with it.
cardMarks = { id: item.id, card, kicker };
card.appendChild(el("h2", null, item.title));
if (item.body) card.appendChild(md(item.body, "md prompt"));
const link = docLink(item);
if (link) card.appendChild(link);
// An item still open on a finished session renders as the same record a
// settled one does: the send it carries is the final word on it, because a
// send can no longer go anywhere and the form would be a trap.
if (!isOpen(item) || finish()) {
renderSettled(card, item);
} else if (flight) {
renderInFlight(card, item, flight);
} else {
const build = BUILDERS[item.kind];
if (build) build(card, item, staged);
}
if (item.required === false && isOpen(item) && !flight && !finish()) {
const skipped = Boolean(staged && staged.skipped);
// A small accent chip, like a comment box's quick answer ("No changes"),
// rather than an underlined link that reads as fine print.
const skip = el("button", "btn tiny", skipped ? "Do not skip" : "Skip this one");
skip.type = "button";
skip.style.marginTop = "16px";
skip.addEventListener("click", () => (skipped ? stage(item.id, null) : skipAndMoveOn(item.id)));
card.appendChild(skip);
if (page.local.skipFlash === item.id) {
card.classList.add("is-skip-flash");
const flash = el("span", "skip-flash", "Skipped");
flash.setAttribute("role", "status");
card.appendChild(flash);
}
}
if (isOpen(item) && !flight && !finish()) markGrowBox(card);
return card;
}
function renderSettled(card, item) {
const v = recordedAnswer(item);
const lines = answerLines(item, v);
const text = v && typeof v.text === "string" ? v.text.trim() : "";
// Fall back to the last thing they said on this question, but only when there
// is nothing else at all. Attaching a side note to a pick they also made
// would misreport which of the two was the answer.
let prose = text;
let fromNote = false;
if (!prose && !lines.length) {
const mine = (item.thread || []).filter((m) => threadWho(m) === "user");
if (mine.length) prose = threadText(mine[mine.length - 1]).trim();
fromNote = Boolean(prose);
}
const nothing = !lines.length && !prose;
const box = el("div", "answered" + (nothing ? " is-empty" : ""));
const head = el("p", "answered-head");
head.appendChild(el("span", "answered-mark", nothing ? "·" : "✓"));
// A note is not an answer: say which it is.
head.appendChild(el("span", null, nothing ? "No answer recorded" : fromNote ? "Your last note" : "Your answer"));
box.appendChild(head);
if (lines.length) {
const ul = el("ul", "answered-values");
for (const line of lines) ul.appendChild(el("li", null, line));
box.appendChild(ul);
}
if (prose) box.appendChild(el("blockquote", "answered-text", prose));
if (nothing) {
box.appendChild(
el(
"p",
"answered-none",
isOpen(item)
? "The session ended before this was answered."
: "This was answered somewhere other than this page, so there is nothing to show."
)
);
}
box.appendChild(
el(
"p",
"answered-lock",
isOpen(item)
? nothing
? "The session is over."
: "The session is over, so this stands as it was sent."
: "Locked. If this needs to change, say so in a note on a question that is still open, or in the terminal."
)
);
card.appendChild(box);
const context = SETTLED_CONTEXT[item.kind];
if (context) context(card, item, v);
}
// The same record, in the moment between pressing Send and the agent replying.
//
// It is deliberately NOT an overlay over the page. The wait is when someone
// re-reads the document, looks ahead at what is coming, or catches up on a
// question they skimmed, and that reading is the whole reason this page beats
// the terminal. What has to stop is editing THIS question, because the agent is
// mid-turn on it: a change made now reaches nobody and is deleted by the next
// update. So the one card that cannot be acted on locks, and nothing else does.
function renderInFlight(card, item, flight) {
const v = flight.value || null;
const lines = answerLines(item, v);
const text = v && typeof v.text === "string" ? v.text.trim() : "";
const box = el("div", "answered is-sent");
const head = el("p", "answered-head");
head.appendChild(el("span", "answered-mark", "↑"));
head.appendChild(el("span", null, "Sent"));
box.appendChild(head);
if (lines.length) {
const ul = el("ul", "answered-values");
for (const line of lines) ul.appendChild(el("li", null, line));
box.appendChild(ul);
} else if (!text && flight.summary) {
// A send from an older page version, or a note with no answer attached.
const ul = el("ul", "answered-values");
ul.appendChild(el("li", null, flight.summary));
box.appendChild(ul);
}
if (text) box.appendChild(el("blockquote", "answered-text", text));
const note = noteAwaiting(item);
const sub = submittedAwaiting(item);
if (note && sub && note.at === sub.at) {
if (note.text) box.appendChild(el("blockquote", "answered-text", note.text));
const tray = sentAttachments(note);
if (tray) box.appendChild(tray);
}
// Say which of the two it actually is. Once the agent has collected the send,
// "waiting to be picked up" is no longer true, and a status line that lies is
// worse than none.
box.appendChild(
el(
"p",
"answered-lock",
page.pendingResult
? "Waiting for Plan2Code to pick this up. It unlocks by itself."
: "Plan2Code is working on it. This unlocks by itself when it answers."
)
);
card.appendChild(box);
const context = SETTLED_CONTEXT[item.kind];
if (context) context(card, item, v);
// A stuck agent must not lock someone out of their own answer forever. This
// is the card-level twin of the Send button's grace period, and it appears on
// the same terms -- a send could actually go through. sendState() is not the
// test here: it is also disabled for an empty payload, and clicking this is
// what stages the payload it would send.
const sendWouldGo =
!finish() && !page.gone && !page.pendingResult && (!agentWorking() || workingMs() > patience(WORKING_GRACE_MS));
if (sendWouldGo) {
const undo = el("button", "linky", "Take this back and answer again");
undo.type = "button";
undo.style.marginTop = "16px";
undo.addEventListener("click", () => {
// Put the answer back as a staged one, exactly the state they were in
// before they pressed Send. Sending clears `staged` and the field's
// draft, so without this the button empties the box it offered to let
// them edit, and a long answer has to be typed a second time.
const back = sentAnswer(page.local.sent[item.id]);
delete page.local.sent[item.id];
// The server also records every send on the item (`submitted`), and that
// record counts as in flight on its own: taking THIS send back has to
// retract it too, or the card stays locked. Its `at` names the send, so
// one made afterwards still counts.
const sub = submittedAwaiting(item);
if (sub) (page.local.retract = page.local.retract || {})[item.id] = sub.at || "any";
if (back) {
page.local.staged[item.id] = back;
} else if (sub) {
// The send came off the server's copy on the item, so its value goes
// back on the form to be edited and sent again.
const { at, ...rest } = sub;
page.local.staged[item.id] = { type: "answer", ...rest };
}
saveNow();
redraw();
});
card.appendChild(undo);
}
}
// The question's own material, shown back as a record. No inputs at all: a
// disabled control still invites a click, a static mark does not.
function lockedOptions(card, item, keys) {
if (!(item.options || []).length) return;
const picked = new Set(keys);
const list = el("ul", "options");
for (const o of item.options) {
const on = picked.has(o.k);
const li = el("li", "option is-locked" + (on ? " is-recorded" : ""));
li.appendChild(el("span", "option-mark" + (on ? " on" : ""), on ? "✓" : "·"));
const body = el("div", "option-body");
const head = el("div", "option-label");
if (showKey(o.k, o.text)) head.appendChild(el("span", "option-key", o.k));
head.appendChild(el("span", null, o.text));
if (on) head.appendChild(el("span", "pill done", "Your answer"));
body.appendChild(head);
if (o.detail) body.appendChild(el("p", "option-detail", o.detail));
li.appendChild(body);
list.appendChild(li);
}
card.appendChild(list);
}
function lockedSteps(card, item, v) {
if (!(item.steps || []).length) return;
const done = new Set((v && v.done) || []);
const list = el("ol", "steps");
item.steps.forEach((step, i) => {
const li = el("li", "step is-locked");
li.appendChild(el("span", "step-num", String(i + 1)));
const on = done.has(i);
li.appendChild(el("span", "option-mark" + (on ? " on" : ""), on ? "✓" : "·"));
const body = el("div", "step-body");
body.appendChild(md(typeof step === "string" ? step : step.text, "md"));
li.appendChild(body);
list.appendChild(li);
});
card.appendChild(list);
}
function lockedRows(card, item, v) {
const rows = (v && Array.isArray(v.rows) && v.rows.length ? v.rows : item.rows) || [];
if (!rows.length) return;
const ul = el("ul", "rows");
rows.forEach((row, i) => {
const li = el("li", "row-item is-locked");
li.appendChild(el("span", "row-order", String(i + 1)));
const main = el("div", "row-main");
main.appendChild(el("p", "row-title-static", row.title || ""));
if (row.body) main.appendChild(el("div", "row-body", row.body));
li.appendChild(main);
ul.appendChild(li);
});
card.appendChild(ul);
}
function lockedSummary(card, item) {
if (!item.summary) return;
const box = el("div", "card-note");
box.appendChild(md(item.summary, "md"));
card.appendChild(box);
}
const SETTLED_CONTEXT = {
choice: (card, item, v) => lockedOptions(card, item, v && v.k ? [v.k] : []),
menu: (card, item, v) => lockedOptions(card, item, v && v.k ? [v.k] : []),
multi: (card, item, v) => lockedOptions(card, item, (v && v.ks) || []),
checklist: lockedSteps,
list: lockedRows,
recap: lockedSummary,
review: lockedSummary,
};
/**
* "Something else" as a real option in the radio group, for a single-choice
* question.
*
* It used to be a plain field below the list, and typing in it MERGED the text
* into whatever was already picked: choosing A and then writing why A is wrong
* sent `a; A is wrong`, the pick first, the contradiction second. Nothing on
* screen said that would happen, and the field's own words ("if none of the
* above fit") promise the opposite.
*
* On a one-answer question these are alternatives, so they share a radio group
* and the last thing touched wins. Qualifying a pick has its own home: the note
* box beside the question, which travels as a comment rather than an answer.
*
* `multi` keeps the additive field below, where naming a third thing alongside
* two ticked boxes is exactly right.
*/
function otherOption(list, item, staged, name) {
if (item.allowOther === false) return;
const id = "other-" + item.id;
const on = Boolean(staged && !staged.k && staged.text);
const li = el("li", "option is-other" + (on ? " is-picked" : ""));
const radio = el("input");
radio.type = "radio";
radio.name = name;
radio.checked = on;
radio.setAttribute("aria-label", "Something else, in your own words");
const body = el("div", "option-body");
const head = el("div", "option-label");
const label = el("label", null, "Something else, in your own words");
label.htmlFor = id;
head.appendChild(label);
body.appendChild(head);
const ta = el("textarea", "other-text");
ta.id = id;
ta.placeholder = "If none of the above fit, say what does.";
// A draft survives picking a listed option, so switching back and forth
// never costs someone the sentence they already wrote.
ta.value = (on && staged.text) || page.local.drafts[id] || "";
// Repaint the row highlights without a full render, which would rebuild this
// textarea mid-keystroke. Setting the radio marks the rest of the group off
// by itself; only the `is-picked` classes need saying out loud.
const pick = (chosen) => {
for (const node of list.children) node.classList.toggle("is-picked", node === chosen);
// The quiet path never re-renders, so the growing box follows the pick here.
markGrowBox(list.closest(".card"));
fitGrowBox();
};
ta.addEventListener("input", () => {
setDraft(id, ta.value);
const v = ta.value.trim();
if (v) {
radio.checked = true;
pick(li);
stageQuiet(item.id, choiceAnswer({ text: v }));
} else {
radio.checked = false;
pick(null);
const cur = page.local.staged[item.id];
if (cur && !cur.k) stageQuiet(item.id, null);
}
stagedChanged();
});
radio.addEventListener("change", () => {
const v = ta.value.trim();
pick(li);
// Nothing written yet: drop the previous pick, since they have just said it
// was not the answer, and put the cursor where the answer now goes.
stageQuiet(item.id, choiceAnswer({ text: v }));
stagedChanged();
ta.focus();
});
body.appendChild(ta);
li.appendChild(radio);
li.appendChild(body);
list.appendChild(li);
}
// The additive twin of otherOption, and the only caller left is `multi`, where
// naming a third thing alongside two ticked boxes is the point. The wording has
// to say that: "if none of the above fit" is the single-choice promise, and it
// would be a lie here, where what you write joins the ticks rather than
// replacing them.
function otherField(card, item, staged) {
if (item.allowOther === false) return;
const wrap = el("div", "field");
const id = "other-" + item.id;
const label = el("label", null, "Anything else, in your own words");
label.htmlFor = id;
wrap.appendChild(label);
const ta = el("textarea");
ta.id = id;
ta.placeholder = "Optional. This adds to the ones you picked above; it does not replace them.";
ta.value = (staged && staged.text) || page.local.drafts[id] || "";
ta.addEventListener("input", () => {
setDraft(id, ta.value);
const cur = page.local.staged[item.id];
if (ta.value.trim()) {
stageQuiet(item.id, { ...(cur || { type: "answer", kind: item.kind }), text: ta.value.trim() });
} else if (cur && cur.text) {
const { text, ...rest } = cur;
if (rest.k || (rest.ks && rest.ks.length)) stageQuiet(item.id, rest);
else stageQuiet(item.id, null);
}
stagedChanged();
});
wrap.appendChild(ta);
card.appendChild(wrap);
}
// Everything that has to catch up after a staged answer changed WITHOUT a full
// render, which is the path every text field takes.
//
// A full render is not an option here: renderMain() empties the column with
// replaceChildren(), and emptying a scrolled container resets its scrollTop, so
// the page would jump to the top on every keystroke. The pieces below are the
// ones that depend on a staged answer and hold no input, so they can be rebuilt
// mid-keystroke safely. Leaving them out is how the card sat with no border and
// the pager kept pointing the wrong way while the footer said "1 ready".
function stagedChanged() {
hooks.renderFooter();
hooks.renderSidebar();
renderStagedMarks();
}
// The topic line, and the one pill that says where this question has got to.
function fillKicker(kicker, item) {
const topic = topics().find((t) => t.id === item.topic);
kicker.replaceChildren(document.createTextNode(topic ? topic.title : "Question"));
let pill = null;
if (!isOpen(item)) pill = el("span", "pill done", item.status === "skipped" ? "Skipped" : "Answered");
// Frozen on a finished session: the send it carries is the record, and a
// staged leftover can no longer be sent, so it earns no pill.
else if (finish()) pill = recordedAnswer(item) ? el("span", "pill done", "Sent") : null;
else if (page.local.staged[item.id]) pill = el("span", "pill staged", "Ready to send");
else if ((page.local.sent && page.local.sent[item.id]) || submittedInFlight(item))
pill = el("span", "pill staged", "Sent");
if (!pill) return;
pill.style.marginLeft = "8px";
kicker.appendChild(pill);
}
function renderStagedMarks() {
const item = byId(page.selected);
if (!item || !cardMarks || cardMarks.id !== item.id || !cardMarks.card.isConnected) return;
cardMarks.card.classList.toggle("is-staged", isOpen(item) && !finish() && Boolean(page.local.staged[item.id]));
fillKicker(cardMarks.kicker, item);
const main = $("main");
const shown = main.querySelector(".pager");
const next = buildPager(item);
if (shown && next) shown.replaceWith(next);
else if (shown) shown.remove();
else if (next) {
// Under its card, not under whatever follows it (the git board).
const card = main.querySelector(":scope > .card, :scope > .git-board > .git-cards > .card");
if (card) card.after(next);
else main.appendChild(next);
}
}
// Update staged state without a full re-render, so typing is never interrupted.
function stageQuiet(id, value) {
if (value == null) delete page.local.staged[id];
else page.local.staged[id] = value;
saveNow();
}
// The next answer for a click, carrying over the words typed on the card. Note
// boxes stage quietly, without a render, so the `staged` a builder closed over
// at render time can be missing everything typed since: read the live answer
// when the click lands instead. A click that clears the pick while text is
// still in the box keeps the text as a note on its own (`bare`), the same shape
// the note box stages when nothing is picked.
function withNote(item, value, bare = { type: "answer", kind: item.kind }) {
const cur = page.local.staged[item.id];
const text = cur && cur.text;
if (!text) return value;
return value ? { ...value, text } : { ...bare, text };
}
// Unique per question and option, and the same on every render.
const optionId = (item, o, i) => `pick-${item.id}-${o.k || i}`;
function buildChoice(card, item, staged) {
const list = el("ul", "options");
const name = "opt-" + item.id;
for (const [i, o] of (item.options || []).entries()) {
const picked = staged && staged.k === o.k;
const li = el("li", "option" + (picked ? " is-picked" : ""));
const label = el("label");
label.style.display = "contents";
const radio = el("input");
radio.type = "radio";
radio.name = name;
// An id so the control survives the render its own change() sets off:
// withFocus finds the focused input by id and has nothing to go on without
// one. Stable across renders because it is built from the question and the
// option, not from a counter.
radio.id = optionId(item, o, i);
radio.value = o.k;
radio.checked = Boolean(picked);
// Without this the group reads out as "A", "B", "on": the letter is the
// label's whole text content, and the last one has no label at all.
radio.setAttribute("aria-label", o.k ? `${o.k}: ${o.text}` : o.text);
// choiceAnswer drops any text that was typed below. On a one-answer
// question a listed option and something in your own words are
// alternatives, and sending both hands the agent an answer that argues
// with itself.
radio.addEventListener("change", () => stage(item.id, choiceAnswer({ k: o.k })));
const body = el("div", "option-body");
const head = el("div", "option-label");
if (showKey(o.k, o.text)) head.appendChild(el("span", "option-key", o.k));
head.appendChild(el("span", null, o.text));
if (o.recommended) head.appendChild(el("span", "pill suggested", "Suggested"));
body.appendChild(head);
if (o.detail) body.appendChild(el("p", "option-detail", o.detail));
label.appendChild(radio);
label.appendChild(body);
li.appendChild(label);
list.appendChild(li);
}
otherOption(list, item, staged, name);
card.appendChild(list);
}
function buildMulti(card, item, staged) {
const chosen = new Set((staged && staged.ks) || []);
const list = el("ul", "options");
for (const [i, o] of (item.options || []).entries()) {
const on = chosen.has(o.k);
const li = el("li", "option" + (on ? " is-picked" : ""));
const label = el("label");
label.style.display = "contents";
const box = el("input");
box.type = "checkbox";
box.id = optionId(item, o, i);
box.value = o.k;
box.checked = on;
box.setAttribute("aria-label", o.k ? `${o.k}: ${o.text}` : o.text);
box.addEventListener("change", () => {
const cur = page.local.staged[item.id];
const next = new Set((cur && cur.ks) || []);
if (box.checked) next.add(o.k);
else next.delete(o.k);
// Unticking the last box keeps what is written in "Anything else".
stage(
item.id,
withNote(item, next.size ? { type: "answer", kind: "multi", ks: [...next] } : null, {
type: "answer",
kind: "multi",
ks: [],
})
);
});
const body = el("div", "option-body");
const head = el("div", "option-label");
if (showKey(o.k, o.text)) head.appendChild(el("span", "option-key", o.k));
head.appendChild(el("span", null, o.text));
if (o.recommended) head.appendChild(el("span", "pill suggested", "Suggested"));
body.appendChild(head);
if (o.detail) body.appendChild(el("p", "option-detail", o.detail));
label.appendChild(box);
label.appendChild(body);
li.appendChild(label);
list.appendChild(li);
}
card.appendChild(list);
card.appendChild(el("p", "help", "Pick as many as apply."));
renderPresets(card, item, staged);
otherField(card, item, staged);
}
// Shortcuts that tick a named set in one go, for a long list where the usual
// answers are groups ("the serious ones", "all of them"): the review's fix
// list is the case it exists for. A preset only ticks boxes. The answer is
// still the ticks, so they can adjust after pressing one, and what reaches the
// agent is the same list it would have got from ticking by hand.
function renderPresets(card, item, staged) {
const known = new Set((item.options || []).map((o) => o.k));
const presets = (Array.isArray(item.presets) ? item.presets : [])
.map((p) => ({ label: String((p && p.label) || "").trim(), ks: ((p && p.ks) || []).filter((k) => known.has(k)) }))
.filter((p) => p.label && p.ks.length);
if (!presets.length) return;
const row = el("div", "btn-row presets");
row.appendChild(el("span", "presets-label", "Quick pick:"));
const now = new Set((staged && staged.ks) || []);
for (const p of presets) {
const on = p.ks.length === now.size && p.ks.every((k) => now.has(k));
const b = el("button", "btn small" + (on ? " primary" : " ghost"), p.label);
b.type = "button";
b.setAttribute("aria-pressed", String(on));
b.addEventListener("click", () =>
stage(
item.id,
withNote(item, on ? null : { type: "answer", kind: "multi", ks: [...p.ks] }, {
type: "answer",
kind: "multi",
ks: [],
})
)
);
row.appendChild(b);
}
card.appendChild(row);
}
function buildText(card, item, staged) {
const wrap = el("div", "field");
const id = "text-" + item.id;
const head = el("div", "field-head");
const label = el("label", null, item.inputLabel || "Your answer");
label.htmlFor = id;
head.appendChild(label);
wrap.appendChild(head);
// Compiled once, here: a pattern that does not compile is treated as no
// pattern at all, rather than throwing on every keystroke (and on Autofill)
// and leaving the answer impossible to stage.
let pattern = null;
if (item.pattern) {
try {
pattern = new RegExp(item.pattern);
} catch {}
}
const single = Boolean(pattern);
const input = el(single ? "input" : "textarea");
if (single) input.type = "text";
input.id = id;
input.placeholder = item.placeholder || "Type here. Plain language is fine.";
input.value = (staged && staged.text) || page.local.drafts[id] || "";
attachMentions(input);
const err = el("p", "field-error");
err.hidden = true;
const suggestion = suggestionFrom(item);
let fill = null;
const check = () => {
setDraft(id, input.value);
// The offer only stands while the box is empty. Overwriting something
// someone typed, from a button they meant to read rather than press, is
// exactly the kind of loss this page is built to avoid.
if (fill) fill.hidden = Boolean(input.value.trim());
const v = input.value.trim();
if (pattern && v) {
// Live validation a terminal simply cannot do. Most often a kebab-case name.
const ok = pattern.test(v);
input.classList.toggle("invalid", !ok);
err.hidden = ok;
err.textContent = item.patternHint || "That is not a valid value.";
if (!ok) {
stageQuiet(item.id, null);
stagedChanged();
return;
}
} else {
input.classList.remove("invalid");
err.hidden = true;
}
stageQuiet(item.id, v ? { type: "answer", kind: "text", text: v } : null);
stagedChanged();
};
input.addEventListener("input", check);
if (suggestion) {
fill = el("button", "btn tiny", "Autofill suggestion");
fill.type = "button";
fill.title = "Put the example into the box. It is yours to edit from there.";
fill.hidden = Boolean(input.value.trim());
fill.addEventListener("click", () => {
input.value = suggestion;
check();
input.focus();
try {
input.setSelectionRange(suggestion.length, suggestion.length);
} catch {}
});
head.appendChild(fill);
}
if (item.templates === "idea" && TEMPLATE_WORKFLOWS.includes(page.S.workflow)) {
wrap.appendChild(templateRow(item, input, templatesFor(page.S.workflow, looks.role), check));
}
wrap.appendChild(input);
// Fresh-idea boxes take files as context, the same ones the note pane holds.
if (!single && TEMPLATE_WORKFLOWS.includes(page.S.workflow)) {
input.addEventListener("paste", (e) => {
const files = incomingFiles(e.clipboardData && e.clipboardData.files);
if (!files.length) return;
if (!e.clipboardData.getData("text/plain")) e.preventDefault();
attachFiles(item.id, files);
});
const under = attachRow(item.id, "Add files to this answer");
under.classList.add("is-under");
wrap.appendChild(under);
const attached = noteImages(item.id);
if (attached.length) wrap.appendChild(attachTray(item.id, attached));
}
if (item.help) wrap.appendChild(el("p", "help", item.help));
wrap.appendChild(err);
card.appendChild(wrap);
}
// The starter templates above a fresh-idea box. The chip choice lives only in
// local.drafts: what gets staged and sent is the box's text, never the id.
function templateRow(item, input, entries, check) {
const key = "tpl-" + item.id;
const row = el("div", "tpl-row");
row.setAttribute("role", "group");
row.setAttribute("aria-label", "Starter templates");
let strip = null;
const selectedEntry = () => entries.find((e) => e.id === page.local.drafts[key]) || entries[0];
// The strip changes the card's height without resizing the column, so the
// column's observer never hears of it: refit the growing box here.
const dropStrip = () => {
if (!strip) return;
strip.remove();
strip = null;
fitGrowBox();
};
const chips = entries.map((entry) => {
const chip = el("button", "tpl-chip", entry.label);
chip.type = "button";
if (entry.forYou) chip.appendChild(el("span", "tpl-pill", "For your role"));
chip.addEventListener("click", () => pick(entry));
row.appendChild(chip);
return chip;
});
const paint = () => {
const selected = selectedEntry();
chips.forEach((chip, i) => chip.setAttribute("aria-pressed", String(entries[i] === selected)));
};
const apply = (entry, text) => {
dropStrip();
input.value = text;
page.local.drafts[key] = entry.id;
check();
saveNow();
paint();
input.focus();
const start = text.indexOf("[");
const end = start < 0 ? -1 : text.indexOf("]", start);
try {
if (end > start) input.setSelectionRange(start, end + 1);
else input.setSelectionRange(text.length, text.length);
} catch {}
};
const pick = (entry) => {
const selected = selectedEntry();
if (entry === selected) return;
const sw = templateSwap({ selectedText: selected.text, boxText: input.value, nextText: entry.text });
if (!sw.confirm) {
apply(entry, sw.text);
return;
}
dropStrip();
strip = el("div", "tpl-replace");
strip.setAttribute("role", "alert");
strip.appendChild(el("span", null, "Replace what you typed?"));
const replace = el("button", "btn tiny primary", "Replace");
replace.type = "button";
replace.addEventListener("click", () => apply(entry, sw.text));
const keep = el("button", "btn tiny ghost", "Keep mine");
keep.type = "button";
keep.addEventListener("click", () => {
dropStrip();
input.focus();
});
strip.append(replace, keep);
row.after(strip);
fitGrowBox();
};
paint();
return row;
}
function buildConfirm(card, item, staged) {
const row = el("div", "btn-row");
const yesLabel = item.yesLabel || "Yes";
const noLabel = item.noLabel || "No";
// An unpicked yes is outlined in the accent, like a review's approve, unless
// the card is dangerous: then it stays red.
const mk = (label, yes, danger) => {
const on = staged && staged.yes === yes;
const b = el(
"button",
"btn" + (on ? " primary" : "") + (danger && !on ? " danger" : "") + (yes && !danger && !on ? " is-approve" : ""),
label
);
b.type = "button";
b.addEventListener("click", () =>
stage(item.id, withNote(item, on ? null : { type: "answer", kind: "confirm", yes }))
);
return b;
};
row.appendChild(mk(yesLabel, true, item.danger));
row.appendChild(mk(noLabel, false, false));
card.appendChild(row);
if (item.consequences) {
// "is-consequences": the command here is what Yes runs, so no "paste it
// into the Ask tab" nudge under it (app.css).
const note = el("div", "card-note is-consequences");
note.appendChild(md(item.consequences, "md"));
card.appendChild(note);
}
if (Array.isArray(item.files) && item.files.length) card.appendChild(filesTable(item.files));
commentField(card, item, "Anything to add?");
}
// A collapsed list of the files a confirm is about ({ path, state } rows), so
// "15 files" can be opened up and read before the person says yes.
function filesTable(files) {
const box = el("details", "card-files");
box.appendChild(el("summary", "", `Show the ${files.length} file${files.length === 1 ? "" : "s"}`));
const table = el("table", "md-table");
const head = el("tr");
head.appendChild(el("th", "", "State"));
head.appendChild(el("th", "", "File"));
table.appendChild(head);
for (const f of files) {
if (!f || typeof f.path !== "string") continue;
const row = el("tr");
row.appendChild(el("td", "", typeof f.state === "string" ? f.state : ""));
row.appendChild(el("td", "", f.path));
table.appendChild(row);
}
box.appendChild(table);
return box;
}
function buildRecap(card, item, staged) {
// The recap is not optional: a click captured the pick, this captures the
// agreement. Rendered as a document so it reads like a summary, not a form.
if (item.summary) {
const box = el("div", "card-note");
box.appendChild(md(item.summary, "md"));
card.appendChild(box);
}
const row = el("div", "btn-row");
const okOn = staged && staged.ok === true;
const fixOn = staged && staged.ok === false;
const ok = el("button", "btn" + (okOn ? " primary" : " is-approve"), item.yesLabel || "Yes, that is right");
ok.type = "button";
ok.addEventListener("click", () => stage(item.id, okOn ? null : { type: "answer", kind: "recap", ok: true }));
const fix = el("button", "btn" + (fixOn ? " primary" : ""), item.noLabel || "Not quite");
fix.type = "button";
fix.addEventListener("click", () =>
stage(item.id, fixOn ? null : { type: "answer", kind: "recap", ok: false })
);
row.appendChild(ok);
row.appendChild(fix);
card.appendChild(row);
if (fixOn) commentField(card, item, "What should it say instead?", true);
}
// A question that is about a document says so on the card, with a way to it.
// The tab row does the same job, but nobody reads a tab row as part of the
// question in front of them: people ticked the review's fix list blind, never
// having noticed the findings sat one tab over.
function docLink(item) {
const doc = item.doc && docs().find((d) => d.id === item.doc);
if (!doc) return null;
const open = el("button", "btn small", `Read “${doc.title || "the document"}” in full`);
open.type = "button";
open.style.marginTop = "14px";
open.addEventListener("click", () => {
page.view = "doc:" + doc.id;
redraw();
});
return open;
}
function buildReview(card, item, staged) {
if (item.summary) {
const box = el("div", "card-note");
box.appendChild(md(item.summary, "md"));
card.appendChild(box);
}
if (item.nothingYet !== false) {
const safe = el("p", "help");
safe.style.marginTop = "14px";
safe.textContent =
item.nothingYet || "Nothing has been changed yet. This only happens once you approve it.";
card.appendChild(safe);
}
const verdicts = item.verdicts || [
{ id: "approve", label: "Looks good, go ahead" },
{ id: "changes", label: "I want changes" },
];
const row = el("div", "btn-row");
for (const v of verdicts) {
const on = staged && staged.verdict === v.id;
// A picked danger verdict stays red (filled), so choosing "Abort" never
// reads like choosing the safe default. An unpicked approve or yes (Build
// it, Archive it) is outlined in the accent, so the main way forward
// stands out.
const forward = v.id === "approve" || v.id === "yes";
const b = el(
"button",
"btn" + (on ? (v.danger ? " danger is-on" : " primary") : v.danger ? " danger" : forward ? " is-approve" : ""),
verdictText(v)
);
b.type = "button";
b.addEventListener("click", () =>
stage(item.id, withNote(item, on ? null : { type: "answer", kind: "review", verdict: v.id }))
);
row.appendChild(b);
}
card.appendChild(row);
// Every gate in the workflow accepts "or describe any issues", so approval
// and feedback are one submit, never two.
commentField(card, item, "Notes, questions, or what to change");
}
function buildChecklist(card, item, staged) {
const doneSet = new Set((staged && staged.done) || []);
// Built from the live answer, so a note typed since the render rides along.
// Nothing ticked, no state and no note is no answer at all: stage nothing
// rather than an empty one that would still count as ready to send.
const commitList = (change) => {
const cur = page.local.staged[item.id];
const next = { ...(cur || {}), type: "answer", kind: "checklist", ...change };
// A tick or a state IS the answer, so it ends a skip staged earlier:
// left in place, `skipped` would collapse the reply to "skip" while the
// card showed ticked steps on their way.
delete next.skipped;
const empty = !(next.done && next.done.length) && !next.state && !next.text;
stage(item.id, empty ? null : next);
};
const list = el("ol", "steps");
(item.steps || []).forEach((step, i) => {
const li = el("li", "step");
const box = el("input");
box.type = "checkbox";
box.id = `step-${item.id}-${i}`;
box.checked = doneSet.has(i);
box.addEventListener("change", () => {
const cur = page.local.staged[item.id];
const next = new Set((cur && cur.done) || []);
if (box.checked) next.add(i);
else next.delete(i);
commitList({ done: [...next] });
});
const label = el("label");
label.htmlFor = box.id;
label.style.flex = "1";
label.appendChild(md(typeof step === "string" ? step : step.text, "md"));
li.appendChild(el("span", "step-num", String(i + 1)));
li.appendChild(box);
li.appendChild(label);
list.appendChild(li);
});
card.appendChild(list);
const states = [
{ id: "done", label: "All done" },
{ id: "blocked", label: "I am stuck" },
{ id: "help", label: "I need help" },
{ id: "defer", label: "Later" },
];
const row = el("div", "btn-row");
for (const s of states) {
const on = staged && staged.state === s.id;
const b = el("button", "btn" + (on ? " primary" : ""), s.label);
b.type = "button";
b.addEventListener("click", () => commitList({ state: on ? null : s.id }));
row.appendChild(b);
}
card.appendChild(row);
commentField(card, item, item.valuesLabel || "Anything you were asked to write down");
}
function buildMenu(card, item, staged) {
const list = el("ul", "options");
const name = "menu-" + item.id;
for (const [i, o] of (item.options || []).entries()) {
const picked = staged && staged.k === o.k;
const li = el("li", "option" + (picked ? " is-picked" : ""));
const label = el("label");
label.style.display = "contents";
const radio = el("input");
radio.type = "radio";
radio.name = name;
// The same id buildChoice gives its radios: withFocus finds the focused
// input by id after the render this change() sets off, and without one a
// keyboard user arrowing through the menu lands on <body> every time.
radio.id = optionId(item, o, i);
radio.value = o.k;
radio.checked = Boolean(picked);
radio.setAttribute("aria-label", o.k ? `${o.k}: ${o.text}` : o.text);
radio.addEventListener("change", () => stage(item.id, { type: "answer", kind: "menu", k: o.k }));
const body = el("div", "option-body");
const head = el("div", "option-label");
head.appendChild(el("span", null, o.text));
if (o.recommended) head.appendChild(el("span", "pill suggested", "Suggested"));
body.appendChild(head);
if (o.detail) body.appendChild(el("p", "option-detail", o.detail));
label.appendChild(radio);
label.appendChild(body);
li.appendChild(label);
list.appendChild(li);
}
card.appendChild(list);
if (item.command) {
const note = el("div", "card-note");
note.appendChild(el("p", "help", "To pick this up in a fresh session, run:"));
note.appendChild(md("```\n" + handoffText({ command: item.command }) + "\n```", "md"));
card.appendChild(note);
}
}
function buildList(card, item, staged) {
// Reorder, rename, remove. The agent proposed a breakdown; this is where a
// person who knows the work fixes it before it becomes the plan.
//
// Every handler re-reads the rows at the moment it fires rather than closing
// over the array from render time. A reorder replaces that array, so a stale
// closure would quietly undo the reorder the next time a rename committed.
// A name still being typed counts too: the tool buttons below keep the
// field's focus (their mousedown is cancelled), so its `change` has not
// fired yet when they act, and the re-render would otherwise drop it.
const ul = el("ul", "rows");
const baseRows = () => {
const cur = page.local.staged[item.id];
return (cur && cur.rows) || (item.rows || []).map((r) => ({ ...r }));
};
const liveRows = () =>
baseRows().map((r) => {
const input = ul.querySelector(`input.row-title[data-row="${CSS.escape(String(r.id))}"]`);
const typed = input ? input.value.trim() : null;
return typed != null && typed !== r.title ? { ...r, title: typed } : r;
});
const rows = liveRows();
// The first click on a tool after a rename used to land on a node the
// rename's re-render had already replaced, and do nothing.
const keepFocus = (b) => b.addEventListener("mousedown", (e) => e.preventDefault());
let dragIndex = null;
const commit = (next) => stage(item.id, withNote(item, { type: "answer", kind: "list", rows: next }));
rows.forEach((row, i) => {
const li = el("li", "row-item");
li.draggable = true;
li.addEventListener("dragstart", () => {
dragIndex = i;
li.classList.add("dragging");
});
li.addEventListener("dragend", () => li.classList.remove("dragging"));
li.addEventListener("dragover", (e) => {
e.preventDefault();
li.classList.add("drop-target");
});
li.addEventListener("dragleave", () => li.classList.remove("drop-target"));
li.addEventListener("drop", (e) => {
e.preventDefault();
li.classList.remove("drop-target");
if (dragIndex === null || dragIndex === i) return;
const next = liveRows();
const [moved] = next.splice(dragIndex, 1);
next.splice(i, 0, moved);
commit(next);
});
const handle = el("button", "row-handle", "⠿");
handle.type = "button";
handle.title = "Drag to reorder";
handle.setAttribute("aria-label", `Move “${row.title}”`);
li.appendChild(handle);
li.appendChild(el("span", "row-order", String(i + 1)));
const main = el("div", "row-main");
// A real input rather than contenteditable: it is reachable by keyboard and
// by a screen reader, it has a stable id so withFocus() can restore the
// caret across a re-render, and `change` fires only when the value actually
// changed, which stops a rename from re-entering render on every blur.
const title = el("input", "row-title");
title.type = "text";
title.id = `row-${item.id}-${row.id}`;
title.value = row.title || "";
title.setAttribute("aria-label", "Name");
title.dataset.row = String(row.id);
// Staged as it is typed (quietly, no re-render, so the caret stays): a
// Ctrl+Enter, a Send, or an agent post landing mid-word all see the new
// name, where `change` alone only fired on blur and they did not.
title.addEventListener("input", () => {
const next = baseRows();
const at = next.findIndex((r) => r.id === row.id);
if (at === -1) return;
next[at] = { ...next[at], title: title.value.trim() };
const untouched =
next.length === (item.rows || []).length && next.every((r, i) => r.id === item.rows[i].id && r.title === item.rows[i].title);
stageQuiet(item.id, untouched && !page.local.staged[item.id] ? null : withNote(item, { type: "answer", kind: "list", rows: next }));
hooks.renderFooter();
renderStagedMarks();
});
title.addEventListener("change", () => {
const next = baseRows();
const at = next.findIndex((r) => r.id === row.id);
if (at === -1) return;
const value = title.value.trim();
if (value === next[at].title) return;
next[at] = { ...next[at], title: value };
commit(next);
});
main.appendChild(title);
if (row.body) main.appendChild(el("div", "row-body", row.body));
li.appendChild(main);
const tools = el("div", "row-tools");
const up = el("button", "btn ghost small", "↑");
up.type = "button";
up.title = "Move up";
up.disabled = i === 0;
up.addEventListener("click", () => {
const next = liveRows();
const at = next.findIndex((r) => r.id === row.id);
if (at <= 0) return;
[next[at - 1], next[at]] = [next[at], next[at - 1]];
commit(next);
});
const down = el("button", "btn ghost small", "↓");
down.type = "button";
down.title = "Move down";
down.disabled = i === rows.length - 1;
down.addEventListener("click", () => {
const next = liveRows();
const at = next.findIndex((r) => r.id === row.id);
if (at === -1 || at === next.length - 1) return;
[next[at + 1], next[at]] = [next[at], next[at + 1]];
commit(next);
});
const del = el("button", "btn ghost small", "×");
del.type = "button";
del.title = "Remove";
del.setAttribute("aria-label", `Remove “${row.title}”`);
del.addEventListener("click", () => commit(liveRows().filter((r) => r.id !== row.id)));
up.setAttribute("aria-label", `Move “${row.title}” up`);
down.setAttribute("aria-label", `Move “${row.title}” down`);
for (const b of [up, down, del]) keepFocus(b);
tools.appendChild(up);
tools.appendChild(down);
tools.appendChild(del);
li.appendChild(tools);
ul.appendChild(li);
});
card.appendChild(ul);
const row = el("div", "btn-row");
const add = el("button", "btn small", "Add one");
add.type = "button";
keepFocus(add);
add.addEventListener("click", () =>
commit([...liveRows(), { id: "new-" + Date.now(), title: "New item", body: "" }])
);
row.appendChild(add);
if (staged) {
const reset = el("button", "linky", "Put it back how it was");
reset.type = "button";
// Puts the rows back; a note typed below stays.
reset.addEventListener("click", () => stage(item.id, withNote(item, null)));
row.appendChild(reset);
}
card.appendChild(row);
card.appendChild(el("p", "help", "Drag to reorder, click a name to rename it."));
const quick = [{ label: "No changes", text: "no changes" }];
// Only a plan's breakdown is phases; a list card elsewhere is something else.
if (PHASE_WORKFLOWS.includes(page.S.workflow)) quick.push({ label: "Combine phases", text: COMBINE_PHASES });
commentField(card, item, "Anything else about this breakdown?", false, quick);
}
const PHASE_WORKFLOWS = ["plan", "revise-plan"];
const COMBINE_PHASES =
"Combine phases where possible to simplify and reduce the total number of phases, while still keeping a clear separation of concerns.";
function commentField(card, item, labelText, required, quickAnswers = []) {
const wrap = el("div", "field");
const id = "note-" + item.id;
const label = el("label", null, labelText);
label.htmlFor = id;
wrap.appendChild(label);
const quicks = quickAnswers.map(({ label, text }) => {
const b = el("button", "btn tiny quick-answer", label);
b.type = "button";
b.title = "Fill in \"" + text + "\"";
wrap.appendChild(b);
return [b, text];
});
const ta = el("textarea");
ta.id = id;
ta.placeholder = required ? "Tell Plan2Code what to change." : "Optional.";
ta.value = (page.local.staged[item.id] && page.local.staged[item.id].text) || page.local.drafts[id] || "";
attachMentions(ta);
ta.addEventListener("input", () => {
setDraft(id, ta.value);
const cur = page.local.staged[item.id];
if (cur) {
const next = { ...cur, text: ta.value.trim() || undefined };
// Emptying the box of a note-only answer leaves nothing to send, so it
// unstages rather than counting as ready.
const empty = (v) => v == null || v === "" || (Array.isArray(v) && !v.length);
const bare = Object.keys(next).every((k) => k === "type" || k === "kind" || empty(next[k]));
stageQuiet(item.id, bare ? null : next);
} else if (ta.value.trim())
stageQuiet(item.id, { type: "answer", kind: item.kind, text: ta.value.trim() });
stagedChanged();
});
wrap.appendChild(ta);
for (const [b, text] of quicks)
b.addEventListener("click", () => {
ta.value = text;
ta.dispatchEvent(new Event("input", { bubbles: true }));
ta.focus();
});
card.appendChild(wrap);
}
// Every builder above may assume its question is OPEN and has no answer in
// flight. renderCard is the only caller and routes the other two states to
// renderSettled and renderInFlight, which draw a record rather than a form.
// The builders used to carry their own half of that job, in `!isOpen` branches
// that no longer run; keeping them would have meant two renderings of a settled
// answer, one of them untested and wrong.
const BUILDERS = {
choice: buildChoice,
multi: buildMulti,
text: buildText,
confirm: buildConfirm,
recap: buildRecap,
review: buildReview,
checklist: buildChecklist,
menu: buildMenu,
list: buildList,
};
// The listeners that keep the cards honest, wired once at start-up: the fade at
// a card's cut edge, the growing note box, and taking back a pending skip.
export function wireCards() {
$("main").addEventListener("scroll", markMore, { capture: true, passive: true });
growObserver?.observe($("main"));
document.addEventListener("pointerdown", cancelSkipMove, true);
document.addEventListener("keydown", cancelSkipMove, true);
}