qr-scan-difficulty-check / web /record_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
8.15 kB
// What a file's own record adds under its as-made facts (made.js), for a picture marked The original graphic, once
// the record checked out (record.js): its kind of art, the square check, the fill, capitals, dots and repeats, and the
// maker's own name for a control after the advice it serves, as plain text in <bdi>; or the one line saying why a
// record is set aside. The words come from copy.json, every number from record.json, sizes.json or the reading.
import { BASE_FRAME, count, el, pctText } from './util.js';
import { t } from './copy.js';
import { needFor, planFor, planWidth, widthText } from './plan.js';
import { smallestVersion } from './capacity.js';
import { ppmText } from './checks.js';
import { ascii, recordSettings, verifiedRecord } from './record.js';
const ASIDE = ['newer', 'unreadable', 'saved', 'unchecked', 'mismatch']; // a record set aside: one line saying why
const NAMED = ['margin', 'contrast', 'error_correction', 'size', 'version']; // the names a record may give
const SERVES = { ec_used: 'error_correction', smaller: 'version', fill: 'version' }; // the control a line's advice names
const FILL = '{control}'; // where the name goes in made.record.control
/** A control's name as the page shows it: white space made spaces; control, format (bidirectional among them) and
* lone surrogate characters removed; runs of spaces made one, and the ends trimmed. '' when that leaves nothing, or
* more than record.json's max_code_points: the advice then stays general. Never anything but text. */
export function cleanName(s) {
const max = recordSettings()?.names.max_code_points;
if (typeof s !== 'string' || !max) return '';
const name = s.replace(/\s/gu, ' ').replace(/[\p{Cc}\p{Cf}\p{Cs}]/gu, '').replace(/ {2,}/g, ' ').trim();
return name && [...name].length <= max ? name : '';
}
/** The record's control names, by control, each cleaned; a name that isn't text, or cleans to nothing, is left out. */
function namesOf(rec) {
const c = rec.controls;
const out = {};
if (c === null || typeof c !== 'object' || Array.isArray(c)) return out;
for (const key of NAMED) {
const name = Object.hasOwn(c, key) ? cleanName(c[key]) : '';
if (name) out[key] = name;
}
return out;
}
/** The line naming a control, split round the name, which goes in as the text of a <bdi>. */
function controlParts(name) {
const [before, after = ''] = t('made.record.control', { control: FILL }).split(FILL);
return [before, el('bdi', { text: name }), after].filter((x) => x !== '');
}
/** made.js: the as-made block's items, [{ text, control? }]. own: the code's facts as [kind, text] ('facts', 'ec' or
* 'ec_used', 'smaller'); u: made.js ecUse(r). With a record that checked out: those lines, each followed by the
* name of the control its advice serves (each control once, after the first line it serves), then the record's own
* lines. With a record set aside: those lines, then one saying why. Otherwise those lines as they are. */
export function recordItems(p, plan, own, u) {
const rec = verifiedRecord(p);
const names = rec ? namesOf(rec) : {};
const used = new Set();
const items = [];
const add = (text, serves) => {
if (!text) return;
items.push({ text });
const name = names[serves];
if (!name || used.has(serves)) return;
used.add(serves);
items.push({ text: t('made.record.control', { control: name }), control: name });
};
for (const [kind, text] of own) add(text, SERVES[kind]);
if (rec) for (const [kind, text] of recordLines(p, plan, rec, u)) add(text, SERVES[kind]);
else if (ASIDE.includes(p.made?.state)) add(t(`made.record.aside.${p.made.state}`));
return items;
}
/** The record's lines, in order: its art (with how many squares read the wrong way, for art drawn in the spare room
* of a code that uses some of its error correction), the square check, the fill, capitals, dots and repeats. */
function recordLines(p, plan, rec, u) {
const r = p.result;
const sq = p.made.squares;
const art = rec.art === 'none' ? '' : t(`made.record.art.${rec.art}`);
const yet = rec.art === 'spare-data' && typeof u === 'number' && u > 0 && sq.wrong >= 1 ? t('made.record.yet', { k: count(sq.wrong) }) : '';
const dots = rec.code.dots;
const size = dots === 'varies' ? 'varies' : dots >= recordSettings().dots.small_below ? 'large' : 'small';
return [
['art', [art, yet].filter(Boolean).join(' ')],
...squareLines(sq).map((s) => ['squares', s]),
['fill', fillLine(r, plan, rec)],
['capitals', rec.content.capitals === 'whole-link' ? t('made.record.capitals.whole-link') : ''],
['dots', dots == null ? '' : t(`made.record.dots.${size}`)],
['repeats', rec.code.grid ? t('made.record.repeats', { p: ppmText(r.checks?.ppm?.native) }) : ''],
];
}
/** The square check: a mirrored code says so first (and then counts only squares that read the wrong way); else all
* the squares read as made, or how many didn't, and how many of those are in the corner patterns. */
function squareLines(sq) {
const vars = { N: count(sq.N), k: count(sq.wrong), pct: pctText(sq.wrong / sq.N), f: count(sq.f) };
const tally = sq.wrong === 0 ? t('made.squares.all', vars) : t(sq.f > 0 ? 'made.squares.wrong' : 'made.squares.wrong_clear', vars);
return sq.mirrored ? [t('made.squares.mirrored'), sq.wrong > 0 ? tally : ''] : [tally];
}
/** The fill: the link alone, whole in an ASCII text the page holds, fits a smaller version at the same error
* correction (capacity.js), with that version's width at the chosen distance; with a printed width typed, the
* version alone, since that answer is a distance. '' otherwise. */
function fillLine(r, plan, rec) {
const lb = rec.content.link_bytes;
const text = r.content?.text;
if (lb == null || !ascii(text) || lb > text.length) return '';
const lv = smallestVersion(text.slice(0, lb), r.ec_level);
if (lv == null || lv >= plan.v) return '';
const lw = plan.mode === 'width' || plan.shape?.cant ? null : planWidth(lv, plan); // with its shape (tilt)
if (lw == null) return t('made.record.fill_width', { lv, v: plan.v });
return t(needFor(lv).floor ? 'made.record.fill_floor' : 'made.record.fill', { lv, lw: widthText(lw), v: plan.v });
}
/** made.js, behind "+": where the dots line comes from, then how the squares are counted and how many of the wrong
* ones are in the other fixed patterns, when some read the wrong way. */
export function recordMore(p) {
const rec = verifiedRecord(p);
if (!rec) return [];
const sq = p.made.squares;
return [
rec.code.dots == null ? '' : t('made.record.more.dots'),
sq.wrong > 0 ? t('made.squares.more.how') : '',
sq.wrong > 0 ? t(sq.g > 1 ? 'made.squares.more.fixed' : sq.g === 1 ? 'made.squares.more.fixed_one' : 'made.squares.more.fixed_none', { g: count(sq.g) }) : '',
].filter(Boolean);
}
/** made.js: an item as the block shows it, a <p> of text, with a control's name as the text of a <bdi>. */
export const itemEl = (item) => (item.control ? el('p', {}, controlParts(item.control)) : el('p', { text: item.text }));
/** yours.js: under a Borderline or Problem check's advice, the file's own name for the control it serves, for a
* picture marked The original graphic whose record checked out: the margin's for the margin check, the contrast's
* for low contrast (not for a light-on-dark code alone), the pixel size's for too few pixels per square in a file read
* at its own size (where the advice is a bigger file), and the version's for a dense code. */
export function checkControl(p, key) {
const rec = verifiedRecord(p);
const plan = rec && p.kind === 'graphic' ? planFor(p) : null;
if (!plan || plan.mode === 'cant' || plan.estimated) return [];
const r = p.result;
const why = r.checks?.[key]?.why || [];
const serves = {
quiet: 'margin', contrast: why.includes('contrast') ? 'contrast' : '', ppm: Math.max(...r.size) <= BASE_FRAME ? 'size' : '',
size: why.includes('dense') ? 'version' : '',
}[key];
const name = serves ? namesOf(rec)[serves] : '';
return name ? [el('span', { class: 'do file-control' }, controlParts(name))] : [];
}