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:
commit
d2f18cb3c7
6 files changed
+472
-92
No files matched your search
@@ -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
@@ -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 } : {});
|
||||
});
|
||||
})();
|
||||
@@ -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>
|
||||
|
||||
Reference in new issue
Block a user