qr-scan-difficulty-check / web /plan_view.js
devmandan's picture
Claude Opus 5.5
Slants and cans, what a phone sees, a test sheet, SVG files and more
378f397 verified
Raw History Blame Contribute Delete
14.2 kB
// The plan on the page: the answer that leads "Your picture", the panel beside the bell, each row, the curve's tooltip
// and the announcement when a picture is read; the distance and width controls; what a phone sees (phone.js) and the
// working behind "+"; and a file's code as made (made.js). A change of distance, width or what the picture shows
// redraws only these, in place, with no server call (plan.js).
import { $, el, textEl } from './util.js';
import { t } from './copy.js';
import { panelVerdict, prefixText, rowVerdict } from './verdict.js';
import { pairLines, pairWith } from './pair.js';
import { madeHead, madeLines, refreshMade } from './made.js';
import { refreshTest, testHead } from './test_view.js';
import { kindChanged } from './test.js';
import { phoneField, refreshPhone } from './phone.js';
import { loadCapacity } from './capacity.js';
import { fail, hintEl, lengthOf, mark, parseNumber, say } from './fields.js';
import { shapeField } from './shape_view.js';
import {
answerLines, answerText, distanceCm, distanceKey, distances, distText, fileFirst, howLines, inRange, lastPreset,
loadPlan as loadSizes, looksLikeFile, looksLikePhoto, planFor, rangeIn, rowLines, setDistance, tableHeads, tableRows,
} from './plan.js';
/** app.js: the page data the plan reads (sizes.json), with the QR standard's capacities a file's lines use. */
export const loadPlan = (url) => Promise.all([loadSizes(url), loadCapacity('data/capacity.json')]);
let onChange = () => {}; // app.js: the rows and the panel follow a change
/** app.js: what to redraw after a change, and its list of pictures (for pairing pictures of one code). */
export function whenPlanChanges(fn, pictures) {
onChange = fn;
pairWith(pictures);
}
let before = ''; // the answer the section showed before its last redraw (refreshPlan)
/** After what the picture shows changed (yours.js, which has redrawn the section): the rows and the panel follow, and
* what changed is said: the new answer, or the context when the answer stays (or can't be planned), with the "looks
* like" suggestion, and a file's as-made lines (made.js). */
export function planChanged(p, fallback) {
if (p.made) p.made.chosen = true; // the visitor chose: a file's own details no longer mark it (record.js)
const plan = planFor(p);
const planned = plan && plan.mode !== 'cant';
const answer = planned && answerText(plan) !== before ? answerText(plan) : '';
onChange();
say([answer || fallback, suggestion(p), ...madeLines(p, plan)].filter(Boolean).join(' '));
kindChanged(p); // a design test settles, stops, or shows again
}
// ---- "Your picture" -----------------------------------------------------------------------------------------------
/** The section's head for a planned picture: the answer as its heading, the lines under it, then the distance, the
* width (a file only) and how it is worked out, each one step away. */
export function planHead(p) {
return [
el('h2', { id: 'yoursTitle', class: 'plan-answer', tabindex: '-1' }),
el('div', { class: 'plan-lines' }),
madeHead(),
testHead(p),
el('div', { class: 'plan-tools' }, [distanceField(p), widthField(p), shapeField(p, { update, unchanged }), phoneField(p), el('details', { class: 'more plan-how' }, [
el('summary', { text: t('plan.how.summary') }), el('div', { class: 'more-body method' }),
])]),
];
}
/** Everything the plan changes in the section, in place: the answer, its lines, a file's as-made lines, whether the
* width shows, the working, the score in the kicker, and whether the reading sits behind "+" (a file planned by its
* own width). */
export function refreshPlan(box, p) {
const plan = planFor(p);
const file = fileFirst(plan);
wrapReading(box, file);
for (const s of box.querySelectorAll('.kicker-score')) s.hidden = file; // the score is the reading's
refreshPair(box, p);
if (!plan || plan.mode === 'cant') return;
const h = box.querySelector('.plan-answer');
if (h) { before = h.textContent; h.textContent = answerText(plan); }
const lines = answerLines(p, plan);
box.querySelector('.plan-lines')?.replaceChildren(...lines.map((s, i) => el('p', { class: i === lines.length - 1 ? 'plan-assume' : '', text: s })));
refreshMade(box, p, plan);
refreshTest(box, p, plan);
const width = box.querySelector('.plan-width');
if (width) width.hidden = !(p.kind === 'graphic' && plan.share);
refreshPhone(box, p, plan); // what a phone sees, drawn again only while its "+" is open
box.querySelector('.plan-how .more-body')?.replaceChildren(...howLines(plan).map((s) => el('p', { text: s })), howTable(plan), sheetLink());
}
/** The test sheet, in a tab of its own so that it prints true to size (sheet.html): the camera, with your own phone. */
const sheetLink = () => el('p', {}, el('a', { href: 'sheet.html', target: '_blank', rel: 'noopener', text: t('plan.how.sheet') }));
/** Whom the picture matches among the others, and what changed (pair.js); redrawn as the list changes. */
export function refreshPair(box, p) {
box.querySelector('.pair')?.replaceChildren(...pairLines(p).map((s, i) => el('p', { class: i ? 'pair-change' : 'pair-same', text: s })));
}
/** A file planned by its own width: its reading, labelled, behind "+"; any other picture: in the open. */
function wrapReading(box, file) {
const inner = box.querySelector('.reading');
if (!inner || inner.parentElement.matches('.reading-file') === file) return;
if (!file) {
inner.parentElement.replaceWith(inner);
return;
}
const wrap = el('details', { class: 'more reading-file' }, el('summary', { text: t('plan.file_reading') }));
inner.replaceWith(wrap);
wrap.append(inner);
}
/** "Looks like a file", or else "if this is the file" for a picture that repeats its code, under Not sure; "looks like
* a photo" under The original graphic: suggestions, never switches. */
export function suggestion(p) {
const r = p.result;
if (p.kind === 'graphic' && p.made?.marked && !p.made.chosen) return t('made.record.marked'); // its own details marked it (record.js)
if (p.kind === 'unsure' && planFor(p)?.mode === 'code' && looksLikeFile(r)) return t('plan.suggest_file');
if (p.kind === 'unsure' && planFor(p)?.copies) return t('plan.suggest_repeat');
if (p.kind === 'graphic' && looksLikePhoto(r)) return t('plan.suggest_photo');
return '';
}
function update(p, announce) {
const box = $('yourPicture');
if (box) refreshPlan(box, p);
onChange();
if (announce) say(answerText(planFor(p)));
}
/** Leaving a box whose value the page already shows: say the answer, and redraw nothing, so a click that moved the
* focus away (onto a row, say) lands where it was aimed. */
const unchanged = (p, announce) => { if (announce) say(answerText(planFor(p))); };
/** "Scanning from closer or further?": the four distances as native radios, and an exact one behind "+". */
function distanceField(p) {
const exact = el('input', { id: 'planExact', class: 'plan-input', type: 'text', inputmode: 'decimal', autocomplete: 'off', 'aria-describedby': 'planExactHint' });
if (distanceKey() === 'exact') exact.value = String(distanceCm());
const [lo, hi] = rangeIn('distance_cm');
const hint = hintEl('planExactHint', t('plan.exact_hint', { lo, hi }));
const radios = distances().map((d) => {
const input = el('input', { type: 'radio', name: 'plan-at', value: d.key, ...(distanceKey() === d.key ? { checked: '' } : {}) });
input.addEventListener('change', () => { setDistance(d.key); exact.value = ''; mark(exact, '', hint); update(p, true); });
return el('label', { class: 'opt' }, [input, el('span', { text: t(`plan.distance.${d.key}.label`, { d: distText(d.cm) }) })]);
});
const typed = (announce) => {
const cm = parseNumber(exact.value);
if (cm === undefined) { // emptied: back to the last of the four chosen
mark(exact, '', hint);
if (distanceKey() !== 'exact') { unchanged(p, announce); return; }
setDistance(lastPreset());
for (const r of radios) { const input = r.querySelector('input'); input.checked = input.value === lastPreset(); }
update(p, announce);
return;
}
if (inRange('distance_cm', cm) == null) { fail(exact, t('plan.exact_invalid', { lo, hi }), hint, announce); return; }
mark(exact, '', hint);
if (distanceKey() === 'exact' && distanceCm() === cm) { unchanged(p, announce); return; }
setDistance('exact', cm);
for (const r of radios) r.querySelector('input').checked = false;
update(p, announce);
};
exact.addEventListener('input', () => typed(false));
exact.addEventListener('change', () => typed(true));
return el('details', { class: 'more plan-distance' }, [
el('summary', { text: t('plan.distance_summary') }),
el('div', { class: 'more-body' }, [
el('fieldset', { class: 'plan-at' }, [el('legend', { class: 'visually-hidden', text: t('plan.distance_legend') }), el('div', { class: 'opts' }, radios)]),
el('details', { class: 'more plan-exact', ...(distanceKey() === 'exact' ? { open: '' } : {}) }, [
el('summary', { text: t('plan.exact_summary') }),
el('div', { class: 'more-body plan-field' }, [el('label', { for: 'planExact', text: t('plan.exact_label') }), exact, hint]),
]),
]),
]);
}
/** "Know how wide it'll be?": a file's printed width, in cm, mm or inches (as a number, or a fraction: parseInches,
* with or without a trailing in, " or ″); the answer becomes how far it scans from. */
function widthField(p) {
const id = `planWidth${p.n}`;
const input = el('input', { id, class: 'plan-input', type: 'text', inputmode: 'decimal', autocomplete: 'off', 'aria-describedby': `${id}Hint` });
const unit = el('select', { class: 'plan-unit', 'aria-label': t('plan.width_unit') }, ['cm', 'mm', 'in'].map((u) => el('option', { value: u, text: u })));
if (p.width) { input.value = p.width.value; unit.value = p.width.unit; }
const keypad = () => input.setAttribute('inputmode', unit.value === 'in' ? 'text' : 'decimal'); // a fraction needs "/"
keypad();
const [lo0, hi0] = rangeIn('width_cm', unit.value);
const hint = hintEl(`${id}Hint`, t('plan.width_hint', { lo: lo0, hi: hi0 }));
const typed = (announce) => {
const [lo, hi] = rangeIn('width_cm', unit.value); // the range in the unit chosen
hint.dataset.text = t('plan.width_hint', { lo, hi });
const next = lengthOf(input.value, unit.value, 'width_cm') ?? null; // as the page read it, which the answer repeats
if (next?.error) { fail(input, t(next.error, { lo, hi }), hint, announce); return; } // not a form it takes, or out of range
mark(input, '', hint);
if (next?.text === p.width?.text) { unchanged(p, announce); return; }
p.width = next;
update(p, announce);
};
input.addEventListener('input', () => typed(false));
input.addEventListener('change', () => typed(true));
unit.addEventListener('change', () => { keypad(); typed(input.value.trim() !== ''); }); // with no width typed, nothing to say
return el('details', { class: 'more plan-width', ...(p.width ? { open: '' } : {}) }, [
el('summary', { text: t('plan.width_summary') }),
el('div', { class: 'more-body plan-field' }, [el('label', { for: id, text: t('plan.width_label') }), el('span', { class: 'plan-pair' }, [input, unit]), hint]),
]);
}
/** The measured table, the picture's own version marked; each distance and width with its inch figure on a second
* line (after a space, so it is read apart). */
function howTable(plan) {
const rows = tableRows();
const caption = t('plan.how.table_caption');
const two = ([metric, inches]) => [metric, ...(inches ? [' ', el('span', { class: 'in', text: inches })] : [])];
return el('div', { class: 'plan-table-wrap', role: 'region', 'aria-label': caption, tabindex: '0' }, el('table', { class: 'plan-table' }, [
textEl('caption', '', caption),
el('thead', {}, el('tr', {}, [[t('plan.how.table_version')], [t('plan.how.table_need')], ...tableHeads()].map((h) => el('th', { scope: 'col' }, two(h))))),
el('tbody', {}, rows.map((r) => el('tr', r.version === plan.need.version ? { class: 'on' } : {}, [
el('th', { scope: 'row', text: r.label }), el('td', { text: r.need }), ...r.widths.map((w) => el('td', {}, two(w))),
]))),
]));
}
// ---- beside the bell, in the list, on the curve, when read -----------------------------------------------------------
/** The panel: the answer first; a file planned by its own width keeps its reading behind "+". */
export function panelPlan(p) {
const plan = planFor(p);
const verdict = panelVerdict(p.result);
if (!plan) return [verdict];
const answer = el('p', { class: `panel-plan${plan.mode === 'cant' || plan.shape?.cant ? ' cant' : ''}`, text: answerText(plan) });
if (!fileFirst(plan)) return [answer, verdict];
return [answer, el('details', { class: 'more panel-file' }, [el('summary', { text: t('plan.file_reading') }), verdict])];
}
/** A row's verdict column: the width and what it's for first, then the level; a file planned by its width, no level. */
export function rowPlan(p) {
const span = rowVerdict(p);
const plan = planFor(p);
const [lead, why] = rowLines(plan);
if (!lead) return span;
const sep = () => el('span', { class: 'pv-sep', text: ', ' });
if (!why) { // a width that can't be planned: a short line before the level
span.prepend(el('span', { class: 'pv-for' }, [lead, sep()]));
return span;
}
const head = [el('span', { class: 'pv-plan' }, [lead, sep()]), el('span', { class: 'pv-for' }, [why, fileFirst(plan) ? null : sep()])];
if (fileFirst(plan)) span.replaceChildren(...head);
else span.prepend(...head);
return span;
}
/** The curve's tooltip lines after the picture's name. */
export function tipLines(p) {
const plan = planFor(p);
const verdict = prefixText(p.result);
if (!plan) return [['k', verdict]];
return [['k', answerText(plan)], ['k', fileFirst(plan) ? t('plan.file_tip', { verdict }) : verdict]];
}
/** What is said when a picture is read: the answer, then the level. */
export function announceText(p) {
return tipLines(p).map(([, s]) => s).join(' ');
}