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