Merge feed paging that skips no role after a vote or a read, a first request that names the agent, the company link by key, and the fetch gate named at the end of the list and in the reader (wp-rev-ui)

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
WolfandClaude Fable 5.1 committed 2026-10-05 10:12:39 +02:00
commit d2f18cb3c7
6 files changed
+472 -92

No files matched your search

+5 -1
View File
@@ -420,9 +420,13 @@
const row = document.createElement("div");
row.className = "crow";
if (company.affinity === -1) row.dataset.hidden = "true";
// By key, as the feed's own company links are, so the Roles page opens
// the company view with its strip and gate note. A name would be a
// substring there, which also lists other companies whose names hold it
// and misses roles spelt otherwise.
const link = document.createElement("a");
link.className = "name";
link.href = `/?company=${encodeURIComponent(company.name)}`;
link.href = `/?company_keys=${encodeURIComponent(company.key)}`;
link.title = "This company's open roles";
link.textContent = company.name;
row.appendChild(link);
+233 -83
View File
@@ -30,6 +30,9 @@
* and each company affinity. One is always picked while any is enabled: the
* one in `?agent=`, else the one this browser viewed last (localStorage),
* else the enabled one with the lowest id, which is the server's default too.
* The feed's first request carries the first two before the agents are in,
* and waits for them when there is neither, since the server gates nothing
* for a request that names no agent (`start`).
* Picking another reloads the feed and the counts under the reader, which
* stays open and is fetched again for that agent's vote.
*
@@ -39,8 +42,10 @@
* the same three whichever agent is viewed, and all carry the agent's votes.
* What fits me needs a CV: an agent without one is shown What I'm looking
* for, as an agentless page is shown Newest. Every order keeps to the
* roles the agent's fetch gate passes, which a note under Viewing as says;
* Show gated (`gated=true`) adds the ones it rejects, with the reason.
* roles the agent's fetch gate passes, which a note under Viewing as says,
* and for a phone, whose rail is shut, the end of the list and the empty
* state; Show gated (`gated=true`) adds the ones it rejects, with the
* reason. The reader says when the gate rejects the role open.
*
* Saved filters belong to the viewing agent (`/api/agents/{id}/filters`):
* pills in the rail, newsdesk's `#active` row, each the query string
@@ -76,14 +81,14 @@
* screen with that company as its one company chip (`?company_keys=`); a
* plain click filters in place and pushes. With one company filtered a strip
* over the feed names it, counts its roles, links its careers page and
* carries its ⊘ ▲ ★ for the viewing agent. `?company=`, `?company_keys=` and
* `?agent=` are how the Companies and Search agents pages link in.
* carries its ⊘ ▲ ★ for the viewing agent. `?company_keys=` and `?agent=`
* are how Settings › Sources and Search agents link in.
*
* Company and Place in the rail are chip inputs (chips.js) on the suggest
* routes: a chip is a company key or a place token (`country:DK`,
* `region:skane`), several joined by OR. `?company=` and `?place=`, the
* substrings of the links from other pages, still filter and show as a chip
* of their own to take off; nothing in the rail types a new one. Seniority
* substrings of older links and saved filters, still filter and show as a
* chip of their own to take off; nothing in the rail types a new one. Seniority
* (a From and a To rung and a Track, `level_from`, `level_to` and `track`)
* and Pay carry the counts of `/api/roles/facets`, asked after each reload
* with the feed's own parameters, so each says what a click would add. The
@@ -91,8 +96,11 @@
* an old `?seniority=` is ignored.
*
* The list is paged: 60 rows, then 60 more each time the end of the list comes
* within 600px of the screen, with the offset the rows already shown. Back to
* this page from another tab puts the same number of rows and the scroll
* within 600px of the screen. The server sorts afresh on every request and a
* vote or a read moves a role in its list or out of it, so the next page
* starts a row earlier for each and a row already on screen is dropped
* (`pageAsk`, `pageMerge`): none is skipped and none is shown twice. Back
* to this page from another tab puts the same number of rows and the scroll
* position back, from sessionStorage.
*/
(function () {
@@ -130,9 +138,9 @@
const TRACKS = { "": "Both", ic: "Individual", people: "People" };
// What the list is in the order of. What I'm looking for is the viewing
// agent's want feed score, moved by its votes; Newest is first seen; What
// fits me is the agent's `judge` total, the roles not judged after by CV
// closeness.
// agent's want feed score, moved by its votes; Newest is the posting date;
// What fits me is the agent's `judge` total, the roles not judged after by
// CV closeness.
const SORTS = { score: "What I\u2019m looking for", cv: "What fits me", time: "Newest" };
// The route's `order` for each.
const ORDERS = { score: "score", time: "newest", cv: "cv" };
@@ -156,10 +164,11 @@
// Everything `clearFilters` has to put back, in one place, so a new filter
// added here cannot be forgotten there. `company` and `place` are the
// substrings of links from other pages; `companyKeys` and `places` are the
// rail's chips. `levelFrom`, `levelTo` and `track` are the seniority range;
// `seniorityUnknown` and `payUnknown` are the "and roles with no level / no
// pay" boxes, asked only while a range, a track or a pay option is picked.
// substrings of older links and saved filters; `companyKeys` and `places`
// are the rail's chips. `levelFrom`, `levelTo` and `track` are the seniority
// range; `seniorityUnknown` and `payUnknown` are the "and roles with no
// level / no pay" boxes, asked only while a range, a track or a pay option
// is picked.
function blankFilter() {
return {
sort: "score", agent: null, period: "all", tags: new Set(), showRead: true,
@@ -193,6 +202,10 @@
tags: [], // [{tag, count, unread}] from /api/filters
items: [], // the rows on screen, in order
total: 0, // how many roles the filters match in all
offset: 0, // how far into the server's list the pages have read
more: false, // the server's list goes on past `offset`
moved: 0, // votes and reads no page has been asked after yet (`pageAsk`)
movedOnce: 0, // those one page has been asked after
loaded: false, // the first page has landed
loading: false, // a page is in flight, so the pager holds off
selected: 0, // which row the keyboard is on
@@ -403,18 +416,73 @@
// -------------------------------------------------------------- loading
/** The most rows one request may ask for (`limit` on /api/roles). */
const MOST = 1000;
/* Where the next page starts and how many rows it asks for. The server
sorts afresh on every request, and a vote moves a role in its order
(`_VOTED_SCORE`) or out of the list (Judged), as a read does with Show
read off. Each row that leaves the part already read lets a row from
below up into it, which a page asked from `offset` would never show, so
the page starts one row earlier for each such change and is that much
longer; the rows it repeats are dropped (`pageMerge`). `moved` holds
each change for two pages, the one asked after it and the next
(`state.moved` and `state.movedOnce`), since a vote still in flight
when a page is asked may land after the server has read that page. */
function pageAsk(offset, moved, page = PAGE) {
const back = Math.min(offset, moved, MOST - page);
return { offset: offset - back, limit: page + back };
}
/* An answer onto the rows on screen: the rows not on screen yet after
them, in the server's order, so the role a pass sank is not shown a
second time; how far into the server's list the pages have now read;
and whether it goes on. A short page is its end whatever `total` says,
since the count and the page are two queries. */
function pageMerge(items, ask, answer) {
const shown = new Set(items.map((r) => r.uid));
const offset = ask.offset + answer.items.length;
return {
items: items.concat(answer.items.filter((r) => !shown.has(r.uid))),
offset,
more: answer.items.length >= ask.limit && offset < answer.total,
};
}
// For the tests, which page through a list sorted afresh without a DOM.
window.feedPaging = { pageAsk, pageMerge };
let feedRequest = 0;
/* The feed has nothing to show, so the empty state offers a retry rather
than leaving the feed blank for good. */
function feedFailed() {
state.feedError = true;
state.loaded = false;
renderFeed();
}
/* A reload starts the list again; an append asks for the rows after the
ones shown. `keep` asks for that many in one go, which is how the list is
put back as it was. The latch is let go only by the newest request: a
reload overtaking an append must not let a second append start with an
offset into the list being replaced. */
ones read (`pageAsk`). `keep` asks for that many in one go, which is how
the list is put back as it was. The latch is let go only by the newest
request: a reload overtaking an append must not let a second append
start with an offset into the list being replaced.
Nothing is asked while no agent is named and the agents have not said
whether there is one, since the server would list every open role,
ungated (`start`); the empty state offers the retry instead. */
async function loadFeed({ append = false, keep = 0 } = {}) {
if (append && (state.loading || state.items.length >= state.total)) return;
if (state.filter.agent === null && !state.agentsLoaded) {
if (!append) feedFailed();
return;
}
if (append && (state.loading || !state.more)) return;
const ask = append ? pageAsk(state.offset, state.moved + state.movedOnce)
: { offset: 0, limit: Math.min(MOST, Math.max(PAGE, keep)) };
const params = feedParams();
params.set("offset", String(append ? state.items.length : 0));
params.set("limit", String(Math.min(1000, Math.max(PAGE, keep))));
params.set("offset", String(ask.offset));
params.set("limit", String(ask.limit));
const moved = state.moved;
const request = ++feedRequest;
state.loading = true;
let data;
@@ -422,23 +490,25 @@
data = await api(`/api/roles?${params}`);
} catch (err) {
// An append failure leaves what is already on screen; a first load or
// a reload has nothing to show, so the empty state offers a retry
// rather than leaving the feed blank for good.
if (!append && request === feedRequest) {
state.feedError = true;
state.loaded = false;
renderFeed();
}
// a reload has nothing to show (`feedFailed`).
if (!append && request === feedRequest) feedFailed();
return;
} finally {
if (request === feedRequest) state.loading = false;
}
if (request !== feedRequest) return;
state.feedError = false;
// The changes made before this page was asked are counted once more, for
// the next; those made while it was in flight wait for theirs.
state.movedOnce = moved;
state.moved -= moved;
const held = append ? state.items[state.selected]?.uid : state.readingUid;
const page = pageMerge(append ? state.items : [], ask, data);
state.total = data.total;
state.items = append ? state.items.concat(data.items) : data.items;
state.items = page.items;
state.offset = page.offset;
state.more = page.more;
state.loaded = true;
const at = held ? state.items.findIndex((r) => r.uid === held) : -1;
state.selected = at >= 0 ? at : append ? state.selected : 0;
@@ -739,7 +809,7 @@
input.set(want);
}
/* `?company=` or `?place=`, the substring a link from another page
/* `?company=` or `?place=`, the substring an older link or saved filter
brought: a plain chip saying what it matches, which takes it off and
pushes, as a filter does. */
function renderText(id, text, noun, key) {
@@ -1340,31 +1410,67 @@
empty.innerHTML = `<h2>Could not load the feed</h2>
<p>The server did not answer. <button type="button" class="linky" data-retry
>Try again</button>.</p>`;
// Without the agents the feed may not know whose it is, so they are
// asked again with it.
const retry = empty.querySelector("[data-retry]");
if (retry) retry.onclick = () => loadFeed();
if (retry) retry.onclick = () => (state.agentsLoaded ? loadFeed() : start());
} else {
// An agent's list is what its fetch gate passes, which a phone,
// whose rail is shut, learns here and at the end of the list.
const filtered = state.q || filtersOn();
const gate = gateKept() ? `${esc(gateOwner())} fetch gate` : "";
empty.innerHTML = filtered
? `<h2>Nothing matches</h2>
<p>No open role fits these filters.
<p>No open role ${gate ? `that passes ${gate} ` : ""}fits these filters.
<button type="button" class="linky" data-clear>Clear them</button> and start again.</p>`
: `<h2>No roles yet</h2>
<p>Nothing has been pulled yet. <a href="/settings/sources#runs">Runs</a> starts one;
<a href="/settings/sources#job-boards">Job boards</a> and
<a href="/settings/sources#company-boards">Company boards</a> decide what it brings in.</p>`;
: gate
? `<h2>No roles yet</h2>
<p>No open role passes ${gate} yet. <a href="/settings/sources#runs">Runs</a>
starts a pull; <a href="/settings/sources#job-boards">Job boards</a> and
<a href="/settings/sources#company-boards">Company boards</a> decide what it
brings in, <a href="/settings/agents">Search agents</a> what the gate passes.</p>`
: `<h2>No roles yet</h2>
<p>Nothing has been pulled yet. <a href="/settings/sources#runs">Runs</a> starts one;
<a href="/settings/sources#job-boards">Job boards</a> and
<a href="/settings/sources#company-boards">Company boards</a> decide what it brings in.</p>`;
const clear = empty.querySelector("[data-clear]");
if (clear) clear.onclick = () => { state.q = ""; $("#search").value = ""; clearFilters(); };
}
}
// The end of the list says which end it is: a list that has run out and
// one that is still loading look the same otherwise.
// one that is still loading look the same otherwise. Whether it has run
// out is the server's to say (`pageMerge`), since the rows on screen
// keep the ones a vote or a read has since taken out of its list.
const end = $("#feed-end");
const n = state.items.length;
end.hidden = !state.loaded || !n;
end.textContent = n < state.total
? "Loading more…"
: `${number.format(n)} ${n === 1 ? "role" : "roles"} — that is all of them.`;
end.textContent = state.more ? "Loading more…" : `${listSaid(n)} — that is all of them.`;
}
/** Whether the list keeps to the viewing agent's fetch gate: there is an
agent, and Show gated is off. */
const gateKept = () => state.filter.agent !== null && !state.filter.gated;
/** Whose fetch gate, for a sentence: the viewing agent's name, or "this
agent's" until the agents are in. */
function gateOwner() {
const agent = viewed();
return agent ? `${agent.name}'s` : "this agent's";
}
/** The rows on screen in words, for the end of the list: how many and,
with an agent viewing, that they are what its fetch gate passes (and
the filters keep), or with Show gated that they hold what it rejects. */
function listSaid(n) {
const roles = `${number.format(n)} ${n === 1 ? "role" : "roles"}`;
if (state.filter.agent === null) return roles;
const gate = `${gateOwner()} fetch gate`;
const filtered = Boolean(state.q) || filtersOn() > (state.filter.gated ? 1 : 0);
if (state.filter.gated) {
return `${roles}${filtered ? " in these filters" : ""}, the ones ${gate} rejects included`;
}
return `${roles} ${n === 1 ? "passes" : "pass"} ${gate}${filtered ? " and these filters" : ""}`;
}
/* With exactly one company filtered, which is where its name leads, a
@@ -1453,7 +1559,8 @@
rows out at once, since a hidden company is never in the feed; where the
others rank waits on the `score` it queued, whose id the affinity route
answers with (`updated.score_job`), and the feed reloads when that has
finished. */
finished. A list the company filter has come off meanwhile has its rows
asked again in the new order, as `renderAffinity` does. */
async function affinityChanged(key, company, updated) {
if (!company) await loadCompanies(state.filter.agent).catch(() => {});
if (updated?.affinity === -1) reload(); else renderFeed();
@@ -1462,6 +1569,7 @@
await scored(updated?.score_job);
if (status()) status().textContent = "";
if (state.filter.companyKeys.includes(key)) reload();
else loadFeed({ keep: state.items.length });
}
/* Wait for the `score` job `job`, the way agents.js's `rescore` waits:
@@ -1561,6 +1669,8 @@
async function markRead(uid) {
const item = state.items.find((r) => r.uid === uid);
if (item && item.read_at) return;
// With Show read off the server's list loses it, see `pageAsk`.
if (!state.filter.showRead) state.moved += 1;
if (item) { item.read_at = new Date().toISOString(); renderFeed(); }
try {
const role = await api(`/api/roles/${encodeURIComponent(uid)}/read`, { method: "POST" });
@@ -1732,6 +1842,10 @@
const waiting = state.summarising === state.readingUid;
const teaser = loaded && !r.article_text && out && (r.description || "").length < TEASER;
// Under the title, in the copy note's style: that the viewing agent's
// fetch gate rejects the role and why (`gated_reason`), since a link
// from elsewhere, a saved role on Applications say, opens one the feed
// never lists.
el.innerHTML = `
<div class="reader-bar">
<span class="judge"></span>
@@ -1755,6 +1869,9 @@
<h1>${esc(r.title || "")}</h1>
${loaded && r.dup_of ? `<p class="reader-note reader-copy">A copy of
<a href="${esc(pathFor(r.dup_of))}">a posting</a> the feed lists once.</p>` : ""}
${loaded && state.filter.agent !== null && r.gated_reason
? `<p class="reader-note reader-copy">Rejected by ${esc(gateOwner())} fetch gate:
${esc(r.gated_reason)}. The feed lists it only with Show gated.</p>` : ""}
${pay ? `<p class="reader-salary">${esc(pay.range)}</p>
${pay.detail ? `<p class="muted small">${esc(pay.detail)}</p>` : ""}
${pay.note ? `<p class="muted small">${esc(pay.note)}</p>` : ""}` : ""}
@@ -1807,14 +1924,21 @@
Companies page, and its two fetch overrides beside them. A company seen
only through a search has no row until its first change creates one, so
the list is reloaded then, and the overrides, which need a row, wait for it.
Hiding reloads the feed, which no longer holds the company's roles. */
Hiding reloads the feed, which no longer holds the company's roles. Any
other stance moves every role of the company once the `score` it queued
has run, up into the rows already read as well as down out of them,
which no page asked from an offset makes up for (`pageAsk`); so the rows
on screen are asked again then, as many, in the new order. */
function renderAffinity(slot, r) {
const company = companies.get(r.company_key);
if (!r.company_key) { slot.replaceChildren(); return; }
slot.replaceChildren(affinityControl(r.company_key, company ? company.affinity : 0, async (updated) => {
if (!company) await loadCompanies(state.filter.agent).catch(() => {});
renderAffinity(slot, r);
if (updated?.affinity === -1) reload(); else renderFeed();
if (updated?.affinity === -1) { reload(); return; }
renderFeed();
await scored(updated?.score_job);
loadFeed({ keep: state.items.length });
}, state.filter.agent));
if (company) {
slot.append(" ", overridesControl(r.company_key, company,
@@ -2124,6 +2248,16 @@
new IntersectionObserver((entries) => {
if (entries.some((e) => e.isIntersecting)) loadFeed({ append: true });
}, { rootMargin: "600px" }).observe($("#feed-end"));
// ▼ ● ▲ and ★, which likes, on a row or in the reader move the role in
// the server's order, or out of its list under Judged or with Show read
// off, which the next page makes up for (`pageAsk`). The keys press the
// same buttons. Counted at the click, failed or undone ones too, since a
// page that starts a row too early only repeats one.
for (const pane of [$("#roles-list"), $("#reader")]) {
pane.addEventListener("click", (e) => {
if (e.target.closest(".judge button")) state.moved += 1;
});
}
// Kept on the way out, whichever way that is, so back finds it.
window.addEventListener("pagehide", keep);
@@ -2143,6 +2277,60 @@
});
}
/* Whose feed it is, then the feed. The server keeps to a fetch gate only
for an agent it is told of, and without one lists every open role, so
the first request carries the agent whenever one is known before the
agents are in: the address's, else the one this browser viewed last
(`storedAgent`). `chooseAgent` checks it against the enabled ones when
they land, and the feed reloads if it picks another. With neither, the
feed waits for the agents: with none enabled the list of every open
role is the right one, and when they cannot be had the feed's error
state offers to try again (`loadFeed`), rather than every open role
passing for the agent's list.
The rest fills in when it arrives and the feed does not wait on it: the
companies, the tag counts, the saved filters. Each one drawn before is
greyed or missing, which is what "no agent" (renderAgent), an unjoined
company (paintRow) and the tag row being empty already mean, so nothing
here is a new state to handle. `keep` and `y` put the list back as it
was (`kept`). Run again by the error state's retry when the agents did
not come. */
async function start({ keep = 0, y = null } = {}) {
if (state.filter.agent === null) state.filter.agent = storedAgent();
const agentsIn = loadAgents().then(() => { chooseAgent(); return true; }, () => false);
const trackedIn = loadTracked().catch(() => {});
// What the reader's fetch and then the feed's first request go out with,
// so the agents landing later know whether either is to be asked again.
const routed = state.filter.agent;
route();
if (state.filter.agent === null) await agentsIn;
const asked = state.filter.agent;
const sortAsked = sortShown();
const enhance = (async () => {
const [ready] = await Promise.all([agentsIn, trackedIn]);
if (!ready) return;
await loadCompanies(state.filter.agent).catch(() => {});
renderRail();
renderActive();
loadFilters().catch(() => {});
loadSaved().catch(() => {});
// Reload for the score and votes when the agent chosen is not the one
// asked for (a remembered one disabled since), and either way bring
// the reader's affinity control and judge buttons up to date, since
// `companies` was still empty when it first painted. What fits me
// asked of an agent with no CV is What I'm looking for.
if (state.filter.agent !== asked || sortShown() !== sortAsked) reload();
else renderFeed();
if (state.readingUid) {
if (state.filter.agent !== routed) refreshReader(state.readingUid);
else renderReader();
}
})();
await loadFeed({ keep });
if (y !== null && !state.readingUid) window.scrollTo(0, y);
await enhance;
}
document.addEventListener("DOMContentLoaded", async () => {
readUrl();
const was = kept();
@@ -2153,44 +2341,6 @@
// Named before the first request, which a token the server does not
// know would turn into a 422 rather than a list.
await labelPlaces();
// The feed is the page; agents and companies are enhancements that fill
// in when they arrive, not something it waits on — a slow or failed
// /api/agents or /api/companies must not leave it blank. Each one drawn
// here is greyed or missing until `enhance` lands, which is what "no
// agent" (renderAgent), an unjoined company (paintRow) and the tag row
// being empty already mean, so nothing here is a new state to handle.
const before = state.filter.agent;
const sortBefore = sortShown();
const enhance = (async () => {
try {
await Promise.all([loadTracked(), loadAgents()]);
chooseAgent();
await loadCompanies(state.filter.agent);
} catch (err) {
return;
}
renderRail();
renderActive();
loadFilters().catch(() => {});
loadSaved().catch(() => {});
// The feed's first request went out with whatever agent `readUrl` had
// (often none): reload for the score and votes once the real one is
// known, and either way bring the reader's affinity control and judge
// buttons up to date, since `companies` was still empty when it first
// painted.
// What fits me asked of an agent with no CV is What I'm looking for.
if (state.filter.agent !== before || sortShown() !== sortBefore) reload();
else renderFeed();
if (state.readingUid) {
if (state.filter.agent !== before) refreshReader(state.readingUid);
else renderReader();
}
})();
route();
await loadFeed({ keep: was ? was.count : 0 });
if (was && !state.readingUid) window.scrollTo(0, was.y || 0);
await enhance;
await start(was ? { keep: was.count, y: was.y || 0 } : {});
});
})();
+12 -8
View File
@@ -46,8 +46,9 @@
<h3 id="viewing-as">Viewing as <a class="linky" href="/settings/agents">agents</a></h3>
<select id="agent" class="rail-select agent-pick" aria-labelledby="viewing-as" hidden></select>
<p id="agent-none" class="rail-note" hidden></p>
{# Every order keeps to the agent's fetch gate (docs/architecture.md,
"5 Feed"), so the filters below only narrow what it passed. #}
{# Every order keeps to the agent's fetch gate (documentation/ADR Fetch
prep and score.md, "5 Feed"), so the filters below only narrow what
it passed. #}
<p id="agent-gate" class="rail-note" hidden></p>
</section>
{# The agent's saved filters (`/api/agents/{id}/filters`), newsdesk's
@@ -74,11 +75,13 @@
</section>
<section>
<h3>Order</h3>
{# Agent match is the viewing agent's final score, Newest is first
seen, CV match the agent's `judge` total against its CV; all carry
that agent's votes and keep to its fetch gate. #}
{# What I'm looking for is the viewing agent's want feed score, Newest
the posting date, What fits me the agent's `judge` total against its
CV; all carry that agent's votes and keep to its fetch gate. The
period counts back over the posting date too, the date a row shows
as its age. #}
<div class="seg" id="sort" role="group" aria-label="Order"></div>
<label class="rail-field" for="period">First seen</label>
<label class="rail-field" for="period">Posted</label>
<select id="period" class="rail-select"></select>
</section>
<section>
@@ -92,8 +95,9 @@
<div class="rail-fields">
{# Company and Place are chip inputs (static/chips.js), each pick a
company key or a place token from the suggest routes. The chips
of `?company=` and `?place=`, the substrings other pages link
with, sit under them to be taken off; nothing types a new one. #}
of `?company=` and `?place=`, the substrings of older links and
saved filters, sit under them to be taken off; nothing types a
new one. #}
<div id="f-company"></div>
<div id="f-company-text" class="rail-legacy" hidden></div>
<div id="f-place"></div>
+189
View File
@@ -0,0 +1,189 @@
// The feed's paging, static/roles.js `pageAsk` and `pageMerge`, without a
// browser: against a fake /api/roles that sorts afresh on every request, as
// the store does, with a pass halving a role's score and a like lifting it a
// fifth (`_VOTED_SCORE`), and Show read off or Judged taking a role out.
//
// node --test tests/js/*.test.mjs
import { test } from "node:test";
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import vm from "node:vm";
// Only what roles.js touches before DOMContentLoaded.
const window = {
matchMedia: () => ({ matches: false, addEventListener() {} }),
addEventListener() {},
};
const document = { addEventListener() {} };
Object.assign(globalThis, { window, document });
vm.runInThisContext(readFileSync(new URL("../../app/static/roles.js", import.meta.url), "utf8"));
const { pageAsk, pageMerge } = window.feedPaging;
const PAGE = 60;
// ------------------------------------------------------------ the server
/** `n` roles, scores falling evenly from 0.99, all unread and unjudged. */
function server(n, { includeRead = true, judged = "" } = {}) {
const roles = Array.from({ length: n }, (_, i) => ({
uid: `r${String(i).padStart(3, "0")}`, score: 0.99 - (i * 0.5) / n, vote: null, read: false,
}));
const voted = (r) => Math.min(1, r.score * (r.vote === -1 ? 0.5 : r.vote === 1 ? 1.2 : 1));
function list() {
return roles
.filter((r) => includeRead || !r.read)
.filter((r) => judged !== "unjudged" || r.vote === null)
.sort((a, b) => voted(b) - voted(a) || a.uid.localeCompare(b.uid));
}
return {
page: ({ offset, limit }) => {
const all = list();
return { items: all.slice(offset, offset + limit).map((r) => ({ uid: r.uid })), total: all.length };
},
uids: () => list().map((r) => r.uid),
// A vote stamps the role read, as `Store.set_vote` does.
vote: (uid, value) => { const r = roles.find((x) => x.uid === uid); r.vote = value; r.read = true; },
read: (uid) => { roles.find((x) => x.uid === uid).read = true; },
};
}
// ------------------------------------------------------------ the client
/** loadFeed's bookkeeping: the pages asked with `pageAsk`, merged with
`pageMerge`, each change counted for two pages. */
function client(api) {
const c = { items: [], offset: 0, more: false, moved: 0, movedOnce: 0 };
c.load = (append = false) => {
const ask = append ? pageAsk(c.offset, c.moved + c.movedOnce) : { offset: 0, limit: PAGE };
const answer = api.page(ask);
c.movedOnce = c.moved;
c.moved = 0;
Object.assign(c, pageMerge(append ? c.items : [], ask, answer));
};
c.toEnd = () => { for (let i = 0; c.more && i < 100; i += 1) c.load(true); };
c.uids = () => c.items.map((r) => r.uid);
return c;
}
/** Every uid once, and nothing the server lists left out. */
function assertWhole(shown, listed) {
assert.equal(new Set(shown).size, shown.length, "a role is shown twice");
const missing = listed.filter((uid) => !shown.includes(uid));
assert.deepEqual(missing, [], "a role is never shown");
}
// ------------------------------------------------------------ pageAsk
test("with nothing moved the next page starts where the last one ended", () => {
assert.deepEqual(pageAsk(120, 0), { offset: 120, limit: PAGE });
});
test("each change starts the page a row earlier and asks for a row more", () => {
assert.deepEqual(pageAsk(120, 3), { offset: 117, limit: PAGE + 3 });
// Never before the first row, and never more than the route allows.
assert.deepEqual(pageAsk(2, 5), { offset: 0, limit: PAGE + 2 });
assert.deepEqual(pageAsk(5000, 4000), { offset: 5000 - 940, limit: 1000 });
});
// ------------------------------------------------------------ pageMerge
test("a row already on screen is dropped and the offset counts what the server sent", () => {
const items = [{ uid: "a" }, { uid: "b" }];
const merged = pageMerge(items, { offset: 1, limit: 3 },
{ items: [{ uid: "b" }, { uid: "c" }, { uid: "d" }], total: 10 });
assert.deepEqual(merged.items.map((r) => r.uid), ["a", "b", "c", "d"]);
assert.equal(merged.offset, 4);
assert.equal(merged.more, true);
});
test("the list ends at the total, or at a short page whatever the total says", () => {
const at = (items, total) => pageMerge([], { offset: 0, limit: 2 }, { items, total });
assert.equal(at([{ uid: "a" }, { uid: "b" }], 2).more, false);
assert.equal(at([{ uid: "a" }], 5).more, false);
assert.equal(at([{ uid: "a" }, { uid: "b" }], 5).more, true);
});
// ------------------------------------------------------------ against the server
test("a page asked from the rows on screen skips a role after a pass (the bug)", () => {
const api = server(200);
let items = api.page({ offset: 0, limit: PAGE }).items;
api.vote(items[2].uid, -1);
while (items.length < api.page({ offset: 0, limit: 1 }).total) {
items = items.concat(api.page({ offset: items.length, limit: PAGE }).items);
}
const uids = items.map((r) => r.uid);
assert.notEqual(new Set(uids).size, uids.length);
assert.ok(api.uids().some((uid) => !uids.includes(uid)));
});
test("a pass on the first page skips nothing and shows nothing twice", () => {
const api = server(200);
const c = client(api);
c.load();
api.vote(c.items[2].uid, -1);
c.moved += 1;
c.toEnd();
assertWhole(c.uids(), api.uids());
assert.equal(c.items.length, 200);
assert.equal(c.more, false);
});
test("likes, passes and undos on several pages skip nothing", () => {
const api = server(500);
const c = client(api);
c.load();
let seed = 7;
const pick = () => { seed = (seed * 48271) % 2147483647; return seed; };
while (c.more) {
for (let i = 0; i < 6; i += 1) {
const uid = c.items[pick() % c.items.length].uid;
api.vote(uid, [-1, 1, null][pick() % 3]);
c.moved += 1;
}
c.load(true);
}
assertWhole(c.uids(), api.uids());
assert.equal(c.items.length, 500);
});
test("with Show read off each role opened costs no role", () => {
const api = server(200, { includeRead: false });
const c = client(api);
c.load();
for (const i of [0, 5, 30, 59]) { api.read(c.items[i].uid); c.moved += 1; }
c.load(true);
api.read(c.items[90].uid);
c.moved += 1;
c.toEnd();
assertWhole(c.uids(), api.uids());
// The read ones stay on screen; the server's list no longer has them.
assert.equal(c.items.length, 200);
assert.equal(api.uids().length, 195);
assert.equal(c.more, false);
});
test("under Judged, Unjudged a vote takes the role out and the next page makes up for it", () => {
const api = server(150, { judged: "unjudged" });
const c = client(api);
c.load();
for (const i of [1, 2, 3]) { api.vote(c.items[i].uid, 1); c.moved += 1; }
c.toEnd();
assertWhole(c.uids(), api.uids());
assert.equal(c.items.length, 150);
});
test("a change counts for the page after the next too, for a vote that lands late", () => {
const api = server(200);
const c = client(api);
c.load();
c.load(true);
// Clicked before the third page was asked, landed after the server read it.
const late = c.items[10].uid;
c.moved += 1;
c.load(true);
api.vote(late, -1);
c.toEnd();
assertWhole(c.uids(), api.uids());
});
+22
View File
@@ -110,3 +110,25 @@ def test_every_page_says_all_locations() -> None:
assert "All countries" not in path.read_text(), path.name
for path in (STATIC.parent / "templates").rglob("*.html"):
assert "All countries" not in path.read_text(), path.name
def test_a_company_on_settings_sources_links_to_its_company_view_by_key() -> None:
"""By key, as the feed's own company links are: a name is a substring on
the Roles page, which lists other companies whose names hold it and
shows no company strip with its gate note."""
script = (STATIC / "companies.js").read_text()
assert "`/?company_keys=${encodeURIComponent(company.key)}`" in script
assert "/?company=" not in script
def test_the_end_of_the_list_the_empty_state_and_the_reader_name_the_fetch_gate() -> None:
"""A phone's rail, which holds the note, is shut, so the end of the list
and the empty state say whose fetch gate the list keeps to, and the
reader says when that gate rejects the role open (`gated_reason`)."""
script = (STATIC / "roles.js").read_text()
assert "`${listSaid(n)} — that is all of them.`" in script
assert '${n === 1 ? "passes" : "pass"} ${gate}' in script
assert "No open role ${gate ? `that passes ${gate} ` : \"\"}fits these filters." in script
assert "No open role passes ${gate} yet." in script
assert "Rejected by ${esc(gateOwner())} fetch gate:" in script
assert "loaded && state.filter.agent !== null && r.gated_reason" in script
+11
View File
@@ -133,3 +133,14 @@ def test_the_reader_excerpt_falls_back_in_the_servers_order() -> None:
description, then teaser, or a teaser-only role's row blanks after Fetch."""
text = (STATIC / "roles.js").read_text("utf-8")
assert "role.summary || role.description || role.teaser" in text
def test_the_period_is_called_posted_as_the_date_it_counts_back_over(
client: TestClient) -> None:
"""`days` keeps `posted_at` within the window, the date a row shows as its
age, so the select is not called First seen."""
rail = client.get("/").text.split('<aside id="rail"', 1)[1].split("</aside>", 1)[0]
assert '<label class="rail-field" for="period">Posted</label>' in rail
assert "First seen" not in rail
template = (STATIC.parent / "templates" / "roles.html").read_text("utf-8")
assert "docs/architecture.md" not in template and "Agent match" not in template