mirror of
https://github.com/jparkerweb/plan2code.git
synced 2026-11-18 13:01:18 -08:00
1659 lines
64 KiB
JavaScript
1659 lines
64 KiB
JavaScript
// 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,
|
||
loopDriving,
|
||
loopWaiting,
|
||
} 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 { makeMdField } from "../md-field.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(".md-host")];
|
||
// 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 .md-host.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 .md-host.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 neighbor 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 grayed
|
||
// "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;
|
||
}
|
||
|
||
// While the Implementation Loop drives, an open card is a record, not a form
|
||
// (FR-15): "handled" when the loop answers it itself, "locked" otherwise. The
|
||
// one exception (FR-14) is a required question the loop does not handle, which
|
||
// stays a live form while it waits for the person.
|
||
function loopLockFor(item) {
|
||
if (!loopDriving() || !isOpen(item) || finish()) return null;
|
||
if (item.handledBy === "loop") return "handled";
|
||
return loopWaiting() && item.required !== false ? null : "locked";
|
||
}
|
||
|
||
function renderLoopLocked(card, item, why) {
|
||
const box = el("div", "answered is-loop " + (why === "handled" ? "is-handled" : "is-locked"));
|
||
if (why === "handled") {
|
||
box.appendChild(el("p", "answered-head loop-tag", "The loop handles this"));
|
||
box.appendChild(el("p", "answered-lock", "The Implementation Loop answers this one itself, so there is nothing to do here."));
|
||
} else {
|
||
box.appendChild(el("p", "answered-lock", "The Implementation Loop is building. This unlocks by itself if it needs you."));
|
||
}
|
||
card.appendChild(box);
|
||
lockedOptions(card, item, []);
|
||
}
|
||
|
||
export function renderCard(item) {
|
||
const staged = page.local.staged[item.id];
|
||
const flight = inFlightFor(item);
|
||
const loopLock = loopLockFor(item);
|
||
const card = el(
|
||
"article",
|
||
"card question" +
|
||
(!isOpen(item) || finish() ? " is-answered" : staged ? " is-staged" : "") +
|
||
(flight ? " is-inflight" : "") +
|
||
(loopLock ? " is-loop-" + loopLock : "")
|
||
);
|
||
|
||
// 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 (loopLock) {
|
||
renderLoopLocked(card, item, loopLock);
|
||
} 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() && !loopLock) {
|
||
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", () => {
|
||
if (!skipped) return skipAndMoveOn(item.id);
|
||
// Keep a note typed with the skip: the box still shows it, so the send must carry it.
|
||
const kept = page.local.staged[item.id];
|
||
stage(item.id, kept && kept.text ? { type: "answer", kind: item.kind, text: kept.text } : null);
|
||
});
|
||
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() && !loopLock) 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 = makeMdField({
|
||
id,
|
||
className: "other-text",
|
||
placeholder: "If none of the above fit, say what does.",
|
||
label: "Something else, in your own words",
|
||
// A draft survives picking a listed option, so switching back and forth
|
||
// never costs someone the sentence they already wrote.
|
||
value: (on && staged.text) || page.local.drafts[id] || "",
|
||
});
|
||
|
||
// Repaint the row highlights without a full render, which would rebuild this
|
||
// box 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();
|
||
});
|
||
|
||
// htmlFor cannot reach a div the way it reached the textarea: the label's
|
||
// click hands the field its focus here instead.
|
||
label.addEventListener("click", () => ta.focus());
|
||
body.appendChild(ta.el);
|
||
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 = makeMdField({
|
||
id,
|
||
placeholder: "Optional. This adds to the ones you picked above; it does not replace them.",
|
||
label: "Anything else, in your own words",
|
||
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.el);
|
||
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);
|
||
clearRow(card, item);
|
||
}
|
||
|
||
// Takes a one-answer question back to how it arrived: no pick, and nothing in
|
||
// "Something else" (its draft too, or the render would put the words straight
|
||
// back). A radio group cannot be unticked by clicking it again, so without
|
||
// this a stray pick could only be swapped for another one. Only the builders
|
||
// call it, and they only run for a form that has not been sent.
|
||
function clearRow(card, item) {
|
||
const row = el("div", "btn-row options-clear");
|
||
const b = el("button", "btn small ghost", "Clear");
|
||
b.type = "button";
|
||
// An id so focus survives the render the click sets off (see withFocus).
|
||
b.id = "clear-" + item.id;
|
||
b.setAttribute("aria-label", "Clear your answer to this question");
|
||
b.addEventListener("click", () => {
|
||
const other = "other-" + item.id;
|
||
if (page.local.drafts[other]) setDraft(other, "");
|
||
stage(item.id, null);
|
||
});
|
||
row.appendChild(b);
|
||
card.appendChild(row);
|
||
}
|
||
|
||
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 = single
|
||
? el("input")
|
||
: makeMdField({
|
||
id,
|
||
placeholder: item.placeholder || "Type here. Plain language is fine.",
|
||
label: item.inputLabel || "Your answer",
|
||
value: (staged && staged.text) || page.local.drafts[id] || "",
|
||
});
|
||
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));
|
||
}
|
||
// A Markdown field's host is .el; the single-line input appends as itself.
|
||
wrap.appendChild(input.el || input);
|
||
if (!single) label.addEventListener("click", () => input.focus());
|
||
// Fresh-idea boxes take files as context, the same ones the note pane holds,
|
||
// and so does any box the page fills from a Notebook tab (Revise plan's
|
||
// "What should change"), whose ticked pictures land here.
|
||
if (!single && (TEMPLATE_WORKFLOWS.includes(page.S.workflow) || item.fill === "note")) {
|
||
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);
|
||
// Under the app a fresh start is the bar's New Session, so say that.
|
||
const text = page.inApp && o.fresh === true ? "Start New Session" : o.text;
|
||
radio.setAttribute("aria-label", o.k ? `${o.k}: ${text}` : 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, 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);
|
||
clearRow(card, item);
|
||
|
||
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 canceled), 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 = makeMdField({
|
||
id,
|
||
placeholder: required ? "Tell Plan2Code what to change." : "Optional.",
|
||
label: labelText,
|
||
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();
|
||
});
|
||
label.addEventListener("click", () => ta.focus());
|
||
wrap.appendChild(ta.el);
|
||
for (const [b, text] of quicks)
|
||
b.addEventListener("click", () => {
|
||
ta.value = text;
|
||
ta.emitInput();
|
||
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);
|
||
}
|