qr-scan-difficulty-check / web /test_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
13.8 kB
// The design test's block in "Your picture", under a file's as-made lines (plan_view.js mounts it): while the test
// waits or runs, how far it has got, what it does and what this browser downloads for it; then its answer, why a
// phone's scanner wasn't in it, and behind "+", how it was tested. The test's state is test.js's; the words come from
// copy.json, every number from test.json or sizes.json. testNote says what changed once, and never the counter.
import { $, WORDS, count, el, join } from './util.js';
import { t } from './copy.js';
import { needFor, planFor } from './plan.js';
import { shaped } from './shape.js';
import { platformKind } from './scanner.js';
const SERVER = ['zxing-cpp', 'wechat']; // the server's scanners, in the order the lines name them
const WAITING = ['queued', 'slot', 'busy', 'upload', 'running'];
let S = null; // web/data/test.json
let act = null; // test.js: { again(p), add(p), leave(p) }
/** test.js, once test.json is in. */
export function useView(settings, actions) {
S = settings;
act = actions;
}
/** test.js: the "How your pictures are placed" lines that say a test sends the picture again, only while tests run
* (on); otherwise the choice's sentence as before. */
export function howTest(on) {
const fill = (id, text) => { const node = document.getElementById(id); if (node) node.textContent = text; };
fill('howTestScanners', on ? t('test.how_scanners') : '');
fill('howTestPrivacy', on ? t('test.privacy') : '');
const s = t(on ? 'how.index_html.selector_test' : 'how.index_html.selector');
if (s) fill('howSelector', s);
}
/** plan_view.js planHead: the block, hidden until the test has something to show, made once per section so that an
* open "+" stays open. Try again, Add and Leave it out are real buttons; each moves focus to the line that takes its
* place, which has tabindex -1, and the size line's two are described by its text. */
export function testHead(p) {
if (!S?.page) return null;
const size = `testSize-${p.n}`;
const button = (cls, what, about) => {
const b = el('button', { type: 'button', class: `linklike ${cls}`, hidden: '' });
if (about) b.setAttribute('aria-describedby', about);
b.addEventListener('click', () => { act[what](p); focusState(p); });
return b;
};
return el('div', { class: 'test', 'data-n': String(p.n), hidden: '' }, [
el('p', { class: 'test-state', id: `testState-${p.n}`, tabindex: '-1' }),
el('p', { class: 'test-hint', hidden: '' }),
el('p', { class: 'test-size', hidden: '' }, [
el('span', { class: 'test-size-text', id: size }), ' ', button('test-offer', 'add', size), ' ',
button('test-leave', 'leave', size),
]),
el('p', { class: 'test-line2', id: `testLine2-${p.n}`, hidden: '' }),
el('p', { class: 'test-acts', hidden: '' }, [button('test-again', 'again'), ' ', button('test-add', 'add')]),
el('details', { class: 'more test-more', hidden: '' }, [
el('summary', { text: t('test.more_summary') }), el('div', { class: 'more-body method' }),
]),
]);
}
/** test.js: the picture's block, when "Your picture" shows it. */
export function paintTest(p) {
const node = $('yourPicture')?.querySelector(`.test[data-n="${p.n}"]`);
if (node) render(node, p, planFor(p));
}
/** plan_view.js refreshPlan: the block in place, its {at} following a typed width. */
export function refreshTest(box, p, plan) {
const node = box.querySelector('.test');
if (node) render(node, p, plan);
}
const set = (node, text) => {
node.textContent = text;
node.hidden = !text;
};
function render(node, p, plan) {
const rec = p.test;
node.hidden = !(rec && rec.state !== 'settling' && p.kind === 'graphic' && plan && plan.mode !== 'cant');
if (node.hidden) return;
const q = (sel) => node.querySelector(sel);
const had = [...node.querySelectorAll('.linklike')].find((b) => b === document.activeElement); // a button with focus
const waiting = WAITING.includes(rec.state);
const one = rec.state === 'done' ? lineOne(rec, plan) : null;
const two = one && one.kind !== 'worse' ? lineTwo(rec) : null; // after "worse" the answer already warns
const size = waiting ? sizeLine(rec, plan) : null;
const name = rec.part?.name ? t(`test.name.${rec.part.name}`) : '';
const state = q('.test-state');
state.textContent = one ? one.text : stateLine(rec, plan);
state.classList.toggle('running', waiting); // not printed: only lines 1 and 2 are
set(q('.test-hint'), waiting ? t('test.hint', { s: S.scenes.s, at: t(`test.at.${at(plan)}_lower`) }) : '');
set(q('.test-size-text'), size?.text || '');
q('.test-size').hidden = !size;
set(q('.test-offer'), size?.offer ? t('test.add', { name }) : '');
set(q('.test-leave'), size?.leave ? t('test.leave') : '');
const line2 = q('.test-line2');
set(line2, two ? t(two.key, { name }) : '');
const again = rec.state === 'failed' ? rec.retry : two?.act === 'again';
set(q('.test-again'), again ? t('rows.again') : '');
q('.test-again').setAttribute('aria-describedby', two ? line2.id : state.id); // heard as retrying the test
set(q('.test-add'), two?.act === 'add' ? t('test.add', { name }) : '');
q('.test-add').setAttribute('aria-describedby', line2.id);
q('.test-acts').hidden = q('.test-again').hidden && q('.test-add').hidden;
const more = one ? moreLines(rec, plan, one.kind) : [];
q('.test-more').hidden = !more.length;
q('.test-more .more-body').replaceChildren(...more.map((s) => el('p', { text: s })));
if (had?.hidden) state.focus(); // it hid by itself (the browser's part ended, or the answer came): focus isn't lost
}
const at = (plan) => (shaped(plan) ? 'flat' : plan.mode === 'width' ? 'distance' : 'width'); // the test is at the flat need
/** The block's first line while the test waits or runs, or its can't line or failure (an answer is lineOne's). The
* counter follows whichever is slower, the server or this browser's scanner while its part runs. */
function stateLine(rec, plan) {
const L = S.limits;
if (rec.state === 'queued') return t('test.queued');
if (rec.state === 'busy') return t('test.busy', { n: rec.n });
if (rec.state === 'failed') return rec.line;
if (rec.state === 'cant') {
const min = plan.v === 1 ? L.min_ppm_v1 : L.min_ppm;
return t(`test.cant.${rec.why}`, { min, mp: L.max_pixels / 1e6, max: L.max_version });
}
const part = rec.part;
return t('test.running', { k: part?.running ? Math.min(rec.done || 0, part.k) : rec.done || 0, s: S.scenes.s });
}
/** Whether this browser's scanner took part: its part ended with an answer (all its scenes, or the early stop). */
const took = (part) => Boolean(part?.answer) && (part.end === 'settled' || part.end === 'complete');
/** The scanners that ran, with their answers: this browser's first (when it took part), then the server's two. */
function ran(rec) {
const own = took(rec.part) ? [{ key: rec.part.name, answer: rec.part.answer }] : [];
return [...own, ...SERVER.map((key) => ({ key, answer: rec.answers[key] }))];
}
const names = (list) => join(list.map((x) => t(`test.name.${x.key}`)));
/** Line 1: worse if any scanner read it worse, naming those that did; as well as a plain code only if every scanner
* did, naming them all; otherwise the test couldn't tell, naming those that couldn't. */
function lineOne(rec, plan) {
const all = ran(rec);
const of = (...answers) => all.filter((x) => answers.includes(x.answer));
const kind = of('worse').length ? 'worse' : of('like').length === all.length ? 'like' : 'unsure';
const who = names(kind === 'worse' ? of('worse') : kind === 'like' ? all : of('close', 'few'));
return { kind, text: t(`test.${kind}`, { at: t(`test.at.${at(plan)}`), who }) };
}
/** The line 2s that send the visitor to Chrome on Android, and the ones that don't, for a code whose two truths differ
* (test_turn.js started), which Chrome on Android keeps its scanner out of. */
const NO_ANDROID = {
'test.missing.google': 'test.missing.google_no_android',
'test.missing.mac_none': 'test.missing.mac_none_no_android',
'test.missing.other': 'test.missing.other_no_android',
};
/** Line 2, after "as well as" or "can't tell", the first that applies: the phone's scanner that wasn't in the test
* and where to get its answer; why this browser's own didn't take part, with Try again or Add where either helps; or
* what this browser can't do, by platform. Never Chrome on Android for a code it keeps its scanner out of. */
function lineTwo(rec) {
const part = rec.part || {};
const away = (key) => ({ key: (rec.truthsDiffer && NO_ANDROID[key]) || key });
if (took(part)) return away(part.name === 'apple' ? 'test.missing.google' : 'test.missing.apple');
if (['start', 'stopped', 'slow'].includes(part.end)) return { key: `test.fallback.${part.end}`, act: 'again' };
if (part.end === 'left' || part.decision === 'offered') return { key: 'test.missing.left_out', act: 'add' };
if (part.decision === 'save_data') return { key: 'test.missing.save_data', act: 'again' };
if (part.decision === 'late' || part.decision === 'broken') return { key: 'test.fallback.start', act: 'again' };
const kind = platformKind(); // no Try again: trying again can't help
const which = { 'chrome-mac': 'mac_none', 'chrome-android': 'android_none' }[kind] || kind;
return away(`test.missing.${which}`);
}
/** The size line while the test waits or runs: this browser's scanner joins (with Leave it out while its part runs),
* or can join (with Add); gone once its part ends by a fallback, the budget or Leave it out. {mb} is the most a test
* of the code's version range downloads, with the frames it takes. */
function sizeLine(rec, plan) {
const part = rec.part;
if (!part || !['joins', 'offered'].includes(part.decision)) return null;
if (part.decision === 'joins' && (part.left || (part.over && !took(part)))) return null; // Leave it out: at once
const range = S.mb[part.frames] || S.mb.jpeg;
const tops = Object.keys(range).map(Number).sort((a, b) => a - b);
const vars = { name: t(`test.name.${part.name}`), mb: range[String(tops.find((v) => plan.v <= v) ?? tops.at(-1))] };
if (part.decision === 'offered') return { text: t('test.hint_offer', vars), offer: true };
return { text: t('test.hint_browser', vars), leave: Boolean(part.running) };
}
/** The limits' figures in words, from test.json's [a, b]: a share of the scans ("3 in 10"), and how often a design
* still passes ("1 time in 30"). */
const share = ([a, b]) => t('test.more.limits_share', { a, b });
const times = ([a, b]) => t(a === 1 ? 'test.more.limits_times_one' : 'test.more.limits_times_many', { a, b });
/** Behind "+", after an answer, each where it applies: the method, the rule, each scanner's own answer (never its
* reads), the Chrome builds measured, what the figures say of the answer's path, the limits of its scenes, the
* figures' scope, and that this browser's reads stayed in the page. */
function moreLines(rec, plan, kind) {
const F = S.figures;
const lim = F.limits;
const limits = {
big: share(lim.big), big_pass: times(lim.big_pass), small: share(lim.small), small_pass: times(lim.small_pass),
};
const own = took(rec.part) ? rec.part.name : '';
const fair = kind !== 'worse';
const cover = (key, figures) => t(`test.more.${key}`, { N: F.N, ...figures });
const pathLine = own ? (fair ? cover(`cover_${own}`, F.cover[own]) : '')
: cover(fair ? 'cover_open' : 'cover_open_worse', F.cover[fair ? 'open' : 'open_worse']);
const [vlo, vhi] = F.scope.versions;
const each = (x) => t('test.more.each', { name: t(`test.name.${x.key}`), result: t(`test.more.result.${x.answer}`) });
const p = needFor(plan.v).ppm.toFixed(1); // p(v): the table's need for the version, as the test renders it
return [
t('test.more.method', { margin: S.frames.margin_squares, s: S.scenes.s, p, v: plan.v }),
t('test.more.rule', { least: S.rule.least_worse, cost: S.rule.like_cost, q: S.rule.q }),
...ran(rec).map(each),
own ? t(`test.more.${own}`, { os: F.chrome[own].os, n: count(F.chrome[own].n) }) : '',
pathLine,
kind === 'like' ? t('test.more.limits', { s: S.scenes.s, ...limits }) : '',
t('test.more.scope', { N: F.N, styles: WORDS[F.scope.styles], vlo, vhi }),
own ? t('test.more.private') : '',
].filter(Boolean);
}
let said = []; // what testNote says in the next frame, in order
/** testNote, the test's polite live region. what: 'queued', 'start', 'busy' or 'end' (the block's first line then),
* named for the picture when asked. Cleared, then written in the next animation frame, as the marking's note is. */
export function announce(p, what, named) {
const rec = p.test;
const plan = planFor(p);
let line = '';
if (what === 'queued') line = t('test.queued');
else if (what === 'start') line = t('test.announce');
else if (what === 'busy') line = t('test.busy', { n: rec.n });
else if (plan) line = rec.state === 'done' ? lineOne(rec, plan).text : stateLine(rec, plan);
sayTestNote(named ? t('test.announce_named', { n: p.n, name: p.name, line }) : line);
}
/** testNote, said once with what else is said there in the same frame, in order: a test's state, or the line
* saying a file's own details marked it as the original graphic (record.js). */
export function sayTestNote(text) {
const node = $('testNote');
if (!node || !text) return;
if (!said.length) {
node.textContent = '';
requestAnimationFrame(() => {
node.textContent = said.join(' ');
said = [];
});
}
said.push(text);
}
/** After Try again, Add or Leave it out: focus on the line that takes the button's place. */
function focusState(p) {
const node = $('yourPicture')?.querySelector(`.test[data-n="${p.n}"] .test-state`);
if (node && !node.closest('.test').hidden) node.focus();
}