Spaces:
Sleeping
Sleeping
File size: 12,466 Bytes
5b3cd1e 811f3a9 5b3cd1e de7cd1e 5b3cd1e 811f3a9 5b3cd1e 811f3a9 5b3cd1e 811f3a9 5b3cd1e de7cd1e 5b3cd1e 378f397 5b3cd1e 811f3a9 5b3cd1e 811f3a9 5b3cd1e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 | // The design test, for each picture marked The original graphic. Once the choice has stood for the settle time, the
// test joins the page's queue and runs by itself, one test at a time, in the order the pictures were marked; its turn
// with the server is test_turn.js's, this browser's scanner scanner.js's, and test_view.js shows it. Marking the
// picture otherwise, or removing it, stops its test; an answer is kept, and shows again when the picture is marked
// The original graphic again. Nothing is stored, and what this browser's scanner read stays in the page.
import { getJson, t } from './copy.js';
import { planFor } from './plan.js';
import { hidden } from './frames.js';
import { decide, fits, partFor, probe, probed, useTest } from './scanner.js';
import { fetchHealth, late, leave, rawNotText, refusal, turn, useTurn } from './test_turn.js';
import { announce, howTest, paintTest, useView } from './test_view.js';
import { mirroredByRecord } from './record.js';
let S = null; // web/data/test.json, or null: the page starts no test
let health = 'unknown'; // the server's test, as /api/health says: 'unknown' (not read, or the read failed), 'on', 'off'
let reading = null; // the health read in flight
let joins = 0; // tests this browser's scanner joined by itself this page session (Try again can pass S.join)
const queue = []; // the pictures whose tests wait their turn, in order
let active = null; // the picture whose test has the page's turn
let lastEnd = 0; // when the page's last test ended
let wake = 0; // the queue's timer
/** app.js, at the start: the test's settings. Never throws: a missing or broken file leaves the test off. */
export async function loadTest(url) {
try {
const s = await getJson(url);
if (!fits(s)) return;
S = s;
useTest(s);
useTurn(s, { paint, tell, joined: () => { joins += 1; queue.forEach(paint); } });
useView(s, { again: retryTest, add: addScanner, leave: leaveOut });
} catch { /* no test: the page loads as before */ }
}
/** Whether the page runs design tests: test.json says so, and the server's test isn't off. */
export const testOn = () => S?.page === true && health !== 'off';
/** yours.js: the choice's hint says a test sends the picture again, only while tests run. */
export const testChoiceHint = () => (testOn() ? t('test.choice_hint') : '');
/** A picture's test record, or null. */
export const testOf = (p) => p.test || null;
/** app.js, once the words are in: "How your pictures are placed" says a test sends the picture again (only while
* tests run); a page closed, reloaded or put in the back-forward cache leaves its test on the server, and a page
* shown again from that cache runs its queue again. Time the page spends frozen (as Chrome freezes a tab in the
* background), when it doesn't run, is left out of the budget for this browser's fetches (frames.js); a page hidden
* but running keeps fetching at the link's own pace, so that time counts. */
export function initTest() {
if (!S?.page) return;
howText();
window.addEventListener('pagehide', leavePage);
window.addEventListener('pageshow', (e) => { if (e.persisted) pump(); });
const away = (e) => hidden(e.type === 'freeze');
for (const type of ['freeze', 'resume']) window.addEventListener(type, away, { capture: true });
}
const howText = () => howTest(testOn());
/** app.js, after pictures are added: the server's test is read once, with the first picture. */
export function testAdded() {
if (S?.page && health === 'unknown' && !reading) readHealth();
}
function readHealth() {
reading = fetchHealth()
.then((h) => { if (h) health = h.design?.on === true ? 'on' : 'off'; }, () => { /* read again next time */ })
.then(() => {
reading = null;
if (health === 'off') {
howText();
for (const p of [...queue]) drop(p);
}
return health;
});
return reading;
}
const healthNow = () => (health !== 'unknown' ? Promise.resolve(health) : reading || readHealth());
/** plan_view.js, after what a picture shows changed (the change's own words said first). The original graphic: its
* test starts once the choice has stood for the settle time (arrowing past it sends nothing), or its kept answer
* shows again. Anything else: a test settling, waiting or running stops, and the server drops it; an answer or a
* can't line is kept, hidden. */
export function kindChanged(p) {
if (!S?.page) return;
if (p.kind === 'graphic' && !p.test) {
const rec = (p.test = fresh({ by: 'visitor', truthsDiffer: rawNotText(p.result) }, 'settling'));
rec.timer = setTimeout(() => gate(p, rec), S.page_waits.settle_s * 1000);
startProbe();
} else if (p.kind !== 'graphic' && p.test && !['done', 'cant'].includes(p.test.state)) {
stop(p);
pump();
}
paint(p);
}
/** app.js, when a picture's reading returns: one already marked The original graphic (read again, or marked by its
* own record) is tested at once, with no settle time. */
export function readingReturned(p) {
if (!S?.page || p.kind !== 'graphic' || p.status !== 'done' || p.test) return;
const rec = (p.test = fresh({ by: 'reading', truthsDiffer: rawNotText(p.result) }, 'settling'));
startProbe();
gate(p, rec);
}
/** app.js, when a picture is removed, or read again (its reading may change): its test stops, the server drops it,
* and nothing is kept. */
export function pictureRemoved(p) {
if (!p.test) return;
stop(p);
pump();
}
/** The probe runs once a page session, when a picture is first marked The original graphic and the server's test is
* on; tests that wait then show what this browser's scanner will do. */
function startProbe() {
healthNow().then((h) => { if (h === 'on') probe().then(() => queue.forEach(paint)); });
}
/** The settle time has passed, or a reading returned: no test (and no line) without a width planned from a scanner's
* version, a kept original, or the server's test on; while /api/health can't be read, the unreachable line, with Try
* again; a line for the page's own refusals; else the queue. */
async function gate(p, rec) {
const plan = planFor(p);
const fit = p.kind === 'graphic' && p.file && plan && plan.mode !== 'cant' && !plan.estimated && !mirroredByRecord(p);
const h = fit ? await healthNow() : 'off';
if (p.test !== rec) return;
if (h !== 'on') {
if (h === 'off') return drop(p);
Object.assign(rec, { state: 'failed', line: t('errors.unreachable'), retry: true });
tell(p, rec, 'end');
return paint(p);
}
rec.why = refusal(p.result, p.drawn);
rec.state = rec.why ? 'cant' : 'queued';
if (rec.why) tell(p, rec, 'end');
else {
queue.push(p);
if (active || queue.length > 1) tell(p, rec, 'queued');
}
paint(p);
pump();
}
/** The queue's first test starts when none of the page's has its turn, between_tests_s after the last one ended. */
function pump() {
clearTimeout(wake);
if (!S || active || !queue.length) return;
const left = lastEnd + S.page_waits.between_tests_s * 1000 - Date.now();
if (left > 0) {
wake = setTimeout(pump, left);
return;
}
active = queue.shift();
run(active, active.test);
}
/** A test's turn: what this browser's scanner does in it (the probe waited for at most probe_wait_s), then the
* server's part (test_turn.js), then its end. */
async function run(p, rec) {
rec.ctl = new AbortController();
rec.state = 'slot';
paint(p);
let out;
try {
rec.part = await decide(rec, joins);
rec.first ||= rec.part.decision; // kept when the test starts again
rec.decided = true;
out = await turn(p, rec, rec.ctl.signal);
} catch (err) { // a failure in the page's words (upload.js), or the server unreachable
const line = err.retry === undefined ? t('errors.unreachable') : err.message;
out = { state: 'failed', line, retry: err.retry !== false };
}
if (p.test === rec && !rec.ctl.signal.aborted) end(p, rec, out);
}
/** A turn ends: an answer, a can't line or a failure, said once; or the test waits at the queue's head again (a 404
* or a lost slot, the first time), or no test runs (the server's test is off). Then the next test's turn. */
function end(p, rec, out) {
rec.ctl.abort();
leave(rec);
active = null;
lastEnd = Date.now();
if (out.off) {
health = 'off';
howText();
for (const q of [p, ...queue]) drop(q);
} else if (out.redo && rec[out.redo] < 1) {
p.test = fresh({ ...rec, [out.redo]: rec[out.redo] + 1 }, 'queued');
queue.unshift(p);
} else {
Object.assign(rec, out.redo ? late() : out);
tell(p, rec, 'end');
}
paint(p);
pump();
}
/** Show the test; one that hasn't started shows what this browser's scanner would do in it. */
function paint(p) {
const rec = p.test;
if (S && rec && !rec.decided && rec.state !== 'settling') rec.part = partFor(rec, joins, probed());
paintTest(p);
}
/** testNote: after the visitor's own marking, the test's first state unnamed (the marking's words were just said);
* then, naming the picture, a test from the queue when it starts or is told busy (once), and each test's last line. */
function tell(p, rec, what) {
if ((what === 'start' && rec.said && (!rec.waited || rec.busy)) || (what === 'busy' && rec.busy)) return;
announce(p, what, rec.said || rec.by !== 'visitor');
rec.said = true;
rec.waited ||= what === 'queued';
rec.busy ||= what === 'busy';
}
/** A new test record: one started again keeps who started it, its first decision, whether it counted towards the
* bound, Add, what was said, how often the server dropped it or its slot, and whether its code's two truths differ
* (test_turn.js: from the first reading where it shows it, rawNotText, else from the 202). */
const fresh = (from, state) => ({
state, by: from.by, first: from.first, counted: from.counted, added: from.added, said: from.said, busy: from.busy,
drops: from.drops || 0, conflicts: from.conflicts || 0, truthsDiffer: from.truthsDiffer,
});
/** A test left: its timer and requests stopped, what the server holds dropped, nothing kept. */
function stop(p) {
const rec = p.test;
clearTimeout(rec.timer);
rec.ctl?.abort();
leave(rec);
if (queue.includes(p)) queue.splice(queue.indexOf(p), 1);
if (active === p) {
active = null;
lastEnd = Date.now();
}
p.test = null;
}
function drop(p) {
if (p.test) stop(p);
paint(p);
}
/** Try again and Add: the test starts afresh at the end of the queue, its old one left on the server; test_view.js
* then moves focus to its state line. A new test, so its busy line is said again if it is told busy. */
function restart(p, rec, extra) {
stop(p);
const waits = Boolean(active) || queue.length > 0;
p.test = { ...fresh(rec, 'queued'), drops: 0, conflicts: 0, said: true, busy: false, waited: waits, ...extra };
queue.push(p);
paint(p);
pump();
}
/** Try again (after a fallback, Save-Data, the deadline, busy or an unreachable server): where line 2 asked to try
* again for this browser's scanner, it comes back, as with Add (never for a part only shown before the test ran). */
export function retryTest(p) {
const rec = p.test;
const again = Boolean(rec?.decided) && ['save_data', 'late', 'broken'].includes(rec.part?.decision);
if (rec) restart(p, rec, { added: rec.added || again });
}
/** Add {name}: before the picture is sent, the test takes this browser's scanner; after, it starts again with it. */
export function addScanner(p) {
const rec = p.test;
if (!rec) return;
if (!['queued', 'slot', 'busy'].includes(rec.state)) {
restart(p, rec, { added: true });
return;
}
rec.added = true;
if (rec.decided && rec.part.decision === 'offered') rec.part.decision = 'joins';
paint(p);
}
/** Leave it out: the browser's part ends at once (its fetches aborted, the polls then carry frames=0), and the test
* finishes with zxing-cpp's and WeChat's answers. */
export function leaveOut(p) {
const part = p.test?.part;
if (!part?.running) return;
part.left = true;
part.ctl.abort();
paint(p);
}
/** pagehide: the active test is left on the server (keepalive, so it goes as the page goes) and waits at the queue's
* head; a page shown again from the back-forward cache runs it again (pageshow). */
function leavePage() {
const p = active;
if (!p) return;
const rec = p.test;
rec.ctl?.abort();
leave(rec, true);
active = null;
p.test = fresh(rec, 'queued');
queue.unshift(p);
paint(p);
}
|