Spaces:
Sleeping
Sleeping
Download web/plan_view.js from devmandan/qr-scan-difficulty-check: direct link, hf CLI and curl.
- Browser
- Download file 14.2 kB
-
https://huggingface.co/spaces/devmandan/qr-scan-difficulty-check/resolve/main/web/plan_view.js
- Command line
-
hf download hf://spaces/devmandan/qr-scan-difficulty-check/web/plan_view.js
-
curl -L -o plan_view.js https://huggingface.co/spaces/devmandan/qr-scan-difficulty-check/resolve/main/web/plan_view.js
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(' '); | |
| } | |