/* The Roles tab: newsdesk's feed and reader, on roledesk's API. * * Three panes, as newsdesk has them (news/newsdesk/web/templates/index.html, * whose functions keep their names here): the rail of filters (`renderRail`), * the feed (`renderFeed`, `loadFeed`), and the reader (`showReader`, * `renderReader`), a third column beside the feed that replaces it below * 60rem. The template renders an empty shell; everything on screen comes from * the JSON routes in app/web/api.py, and every request goes through `api()` * from app.js, so a failure is one toast carrying the server's own sentence. * * A row is newsdesk's `.row`: the score gutter and number (hidden under * Newest first, since the score is not what put the row there), the title, * company · place · badges · age · tags, the summary or the description's * opening, and ▲ ● ▼ ★ from judge.js. A passed role and a hidden company's * are dimmed, never dropped, so a stray tap stays visible to be undone. * * Opening a role pushes `/roles/{uid}`; closing goes back. Stepping with j/k * while it is open replaces that entry rather than stacking one per role, so * back always means "out of the reader". The server answers `/roles/{uid}` * with this same page, and `route` is the only thing that reads the path. * * The filters are in the query string, replaced rather than pushed, so a * reload or a link keeps them and the back button is not buried under them. * `?company=` and `?agent=` are how the Companies and Ranking pages link in. * * 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 * position back, from sessionStorage. */ (function () { "use strict"; const { api, esc, debounce, companies, loadCompanies, affinityControl, judgeButtons, loadTracked } = window; const $ = (sel, root = document) => root.querySelector(sel); // Below this the rail is over the feed rather than beside it, and the reader // replaces the feed. Asked of the stylesheet's own breakpoint rather than // measured in pixels, so a larger root font size cannot make the two // disagree (newsdesk's reasoning). const narrow = window.matchMedia("(max-width: 60rem)"); const overlayRail = () => narrow.matches; const PAGE = 60; /** Shorter than this and not fetched: the description is a teaser. */ const TEASER = 500; /** How many rows and how far down, for coming back to this page. */ const KEPT = "roledesk.roles"; const number = new Intl.NumberFormat("en"); // What the list is in the order of. Best first is the first enabled // ranking's score, moved by the role's vote; Newest first is first seen. const SORTS = { score: "Best first", time: "Newest first" }; // The named windows over `days`, which counts back from now. const PERIODS = { all: { label: "Any time", days: null }, today: { label: "Today", days: 1 }, week: { label: "This week", days: 7 }, month: { label: "This month", days: 30 }, }; // Everything `clearFilters` has to put back, in one place, so a new filter // added here cannot be forgotten there. function blankFilter() { return { sort: "score", agent: null, period: "all", tags: new Set(), showRead: true, company: "", place: "", function: "", remote: "", judged: "", showMuted: false, gated: false, }; } const state = { filter: blankFilter(), q: "", railOpen: !narrow.matches, railAutoShut: false, // the reader folded the rail, so closing unfolds it agents: [], // the enabled rankings, from /api/agents tags: [], // [{tag, count, unread}] from /api/filters items: [], // the rows on screen, in order total: 0, // how many roles the filters match in all 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 reading: null, // the fetched role, or null while it loads readingUid: null, // set before the fetch lands, so a late answer is dropped pushedReader: false, // we own a history entry, so closing is `history.back()` summarising: null, // the uid whose summary is being waited for listY: 0, // where the page was scrolled when the reader replaced the feed }; const safeUrl = (u) => (/^https?:\/\//i.test(u || "") ? u : ""); function ago(iso) { const mins = (Date.now() - new Date(iso)) / 60000; if (!Number.isFinite(mins)) return ""; if (mins < 60) return `${Math.max(0, Math.round(mins))}m`; if (mins < 1440) return `${Math.round(mins / 60)}h`; return `${Math.round(mins / 1440)}d`; } // ------------------------------------------------------------ the order /** The ranking the list is ordered by, or null for Newest first. Best first with no ranking enabled is Newest first; an `agent` from the URL that is not an enabled ranking falls back to the first one. */ function rankedBy() { if (state.filter.sort !== "score" || !state.agents.length) return null; const chosen = state.agents.find((a) => a.id === state.filter.agent); return (chosen || state.agents[0]).id; } const sortShown = () => (rankedBy() === null ? "time" : "score"); function feedParams() { const f = state.filter; const p = new URLSearchParams(); if (state.q) p.set("q", state.q); for (const key of ["company", "place"]) if (f[key].trim()) p.set(key, f[key].trim()); for (const key of ["function", "remote", "judged"]) if (f[key]) p.set(key, f[key]); const days = PERIODS[f.period].days; if (days) p.set("days", String(days)); if (f.showMuted) p.set("show_muted", "true"); if (!f.showRead) p.set("include_read", "false"); f.tags.forEach((t) => p.append("tags", t)); const agent = rankedBy(); if (agent !== null) { p.set("agent", String(agent)); if (f.gated) p.set("gated", "true"); } return p; } // ------------------------------------------------ filters in the address const PERIOD_OF_DAYS = { 1: "today", 7: "week", 30: "month" }; /** The query string into the filter, once, at load. */ function readUrl() { const q = new URLSearchParams(location.search); const f = state.filter; state.q = q.get("q") || ""; for (const key of ["company", "place", "function", "remote", "judged"]) { f[key] = q.get(key) || ""; } f.period = PERIOD_OF_DAYS[q.get("days")] || "all"; f.showMuted = q.get("show_muted") === "true"; f.showRead = q.get("include_read") !== "false"; f.gated = q.get("gated") === "true" || q.get("gated") === "1"; f.tags = new Set(q.getAll("tags")); if (q.get("sort") === "time") f.sort = "time"; if (q.get("agent")) { f.sort = "score"; f.agent = Number(q.get("agent")); } if (f.company || f.place || f.function || f.remote || f.judged || f.showMuted || f.gated) { $("#f-more").open = true; } } /** The filter into the query string, replacing the entry rather than adding one: a filter is a question, not a place. */ function writeUrl() { const p = feedParams(); p.delete("agent"); p.delete("gated"); const f = state.filter; if (f.sort === "time") p.set("sort", "time"); else if (f.agent !== null) p.set("agent", String(f.agent)); if (f.gated && f.sort === "score") p.set("gated", "true"); const query = p.toString(); const url = location.pathname + (query ? `?${query}` : ""); if (url !== location.pathname + location.search) history.replaceState(history.state, "", url); } // -------------------------------------------------------------- loading let feedRequest = 0; /* 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. */ async function loadFeed({ append = false, keep = 0 } = {}) { if (append && (state.loading || state.items.length >= state.total)) return; const params = feedParams(); params.set("offset", String(append ? state.items.length : 0)); params.set("limit", String(Math.min(1000, Math.max(PAGE, keep)))); const request = ++feedRequest; state.loading = true; let data; try { data = await api(`/api/roles?${params}`); } catch (err) { return; } finally { if (request === feedRequest) state.loading = false; } if (request !== feedRequest) return; const held = append ? state.items[state.selected]?.uid : state.readingUid; state.total = data.total; state.items = append ? state.items.concat(data.items) : data.items; state.loaded = true; const at = held ? state.items.findIndex((r) => r.uid === held) : -1; state.selected = at >= 0 ? at : append ? state.selected : 0; renderFeed(); renderStats(); // Still within reach of the end after a short page: the observer only // fires on a change, and nothing changed, so ask again here. requestAnimationFrame(() => { const end = $("#feed-end").getBoundingClientRect(); if (end.height && end.top < window.innerHeight + 600) loadFeed({ append: true }); }); } /* A different list starts at the top. Without this the window stays where the last one was scrolled to, the end of a shorter list is immediately in view, and picking a filter silently fetches pages nobody asked for. */ function reload() { loadFeed().then(() => { window.scrollTo(0, 0); $("#list").scrollTop = 0; }); } async function loadAgents() { state.agents = (await api("/api/agents")).filter((a) => a.enabled); } // The tag counts. Asked with `show_muted` only, the one filter the route // takes, so picking a tag does not renumber the others. let filtersRequest = 0; async function loadFilters() { const params = new URLSearchParams(); if (state.filter.showMuted) params.set("show_muted", "true"); const request = ++filtersRequest; const data = await api(`/api/filters?${params}`); if (request !== filtersRequest) return; state.tags = data.tags || []; renderRail(); } // ------------------------------------------------------------ the rail function setFilter(patch = {}, { counts = false } = {}) { Object.assign(state.filter, patch); writeUrl(); // A filter is a question about the feed, and the role open over the old // answer is the wrong thing to leave on screen. Its entry is replaced // rather than popped, or back would land on the list the filter just left. if (state.readingUid) navigate(pathFor(null), { replace: true }); reload(); if (counts) loadFilters().catch(() => {}); renderRail(); renderActive(); } function clearFilters() { const kept = { agent: state.filter.agent }; state.filter = Object.assign(blankFilter(), kept); setFilter({}, { counts: true }); } // Text that has not changed is not a change: without this, Escape in an // empty box would shut the reader and call it a search. function setSearch(q) { if (q === state.q) return; state.q = q; setFilter({}); } function toggleTag(tag) { const tags = state.filter.tags; if (tags.has(tag)) tags.delete(tag); else tags.add(tag); setFilter({}); } // An explicit toggle sticks: closing the reader won't undo a choice you made. function toggleRail() { state.railOpen = !state.railOpen; state.railAutoShut = false; renderRail(); } /** A text field or select's value, written only when it differs, so the caret of the field being typed in is left where it is. */ function setValue(id, value) { const el = document.getElementById(id); if (el.type === "checkbox") el.checked = Boolean(value); else if (el.value !== value) el.value = value; } function renderRail() { const f = state.filter; $("#show-read").setAttribute("aria-pressed", String(f.showRead)); // The order. One ranking, or none, is the segmented control; more than one // is a select naming each, so none is lost. const ranked = rankedBy(); const many = state.agents.length > 1; $("#sort").hidden = many; $("#agent").hidden = !many; if (many) { const select = $("#agent"); select.replaceChildren(...state.agents.map((a) => new Option(a.name, String(a.id))), new Option(SORTS.time, "")); select.value = ranked === null ? "" : String(ranked); } else { const none = !state.agents.length; $("#sort").innerHTML = Object.entries(SORTS).map(([key, label]) => { const off = key === "score" && none; return ``; }).join(""); $("#sort").querySelectorAll("[data-sort]").forEach((b) => { b.onclick = () => { if (b.getAttribute("aria-disabled") === "true") return; setFilter({ sort: b.dataset.sort }); }; }); } $("#show-gated").hidden = ranked === null; $("#period").value = f.period; // Tags are chips, multi-select. One the filter holds stays on the list // even when nothing carries it any more, so it can still be taken off. const live = state.tags.filter((t) => t.count > 0); for (const tag of f.tags) { if (!live.some((t) => t.tag === tag)) live.push({ tag, count: 0, unread: 0 }); } $("#tags").innerHTML = live.map((t) => ` `).join(""); $("#tags").querySelectorAll("[data-tag]").forEach((b) => { b.onclick = () => toggleTag(b.dataset.tag); }); $("#clear-tags").hidden = f.tags.size === 0; const note = $("#tag-note"); note.hidden = live.length > 0; note.textContent = "No role is tagged yet."; setValue("f-company", f.company); setValue("f-place", f.place); setValue("f-function", f.function); setValue("f-remote", f.remote); setValue("f-judged", f.judged); setValue("f-show-muted", f.showMuted); setValue("f-gated", f.gated); const more = [f.company.trim(), f.place.trim(), f.function, f.remote, f.judged, f.showMuted, ranked !== null && f.gated].filter(Boolean).length; $("#f-active").textContent = more ? ` · ${more}` : ""; document.body.dataset.rail = state.railOpen ? "open" : "shut"; $("#rail-toggle").setAttribute("aria-expanded", String(state.railOpen)); } /* With the rail shut, which is every narrow screen, the burger is the only thing left that can say a filter is on, so it says how many, in words: a number in a circle reads as "new things" on the one control that means things are being left out (newsdesk's reasoning). */ function renderActive() { const f = state.filter; const on = [!f.showRead, f.period !== "all", f.company.trim(), f.place.trim(), f.function, f.remote, f.judged, f.showMuted, rankedBy() !== null && f.gated] .filter(Boolean).length + f.tags.size; const count = on === 1 ? "1 filter" : `${on} filters`; $(".rail-toggle-label").textContent = on ? count : "Menu"; $("#rail-toggle").setAttribute("aria-label", on ? `Menu — ${count} on` : "Menu"); } function renderStats() { const noun = state.total === 1 ? "role" : "roles"; $("#rail-stats").textContent = state.loaded ? `${number.format(state.total)} ${noun} match` : ""; } // ------------------------------------------------------------ the feed // Add, drop, patch, never rebuild (newsdesk's `sync`): a row that stays // keeps its element, and with it its buttons and its focus. `entries` are // [key, item] pairs in screen order, `make` builds an element for a new // one, and `fill` writes this render's values into one that stays. function sync(parent, entries, make, fill) { const had = new Map(); for (const el of parent.children) had.set(el.dataset.key, el); let last = null; for (const [key, item] of entries) { const k = String(key); let el = had.get(k); if (el) had.delete(k); else { el = make(item); el.dataset.key = k; } fill(el, item); // Where it belongs, and left alone when it is already there, since // moving a node is a remove and an insert. const at = last ? last.nextElementSibling : parent.firstElementChild; if (el !== at) parent.insertBefore(el, at); last = el; } for (const el of had.values()) el.remove(); } /* The summary when there is one, else the description's opening, cut at a word. */ function excerpt(role) { if (role.summary) return role.summary; const text = (role.description || "").replace(/\s+/g, " ").trim(); if (text.length <= 160) return text; const cut = text.slice(0, 160); const space = cut.lastIndexOf(" "); return `${(space > 100 ? cut.slice(0, space) : cut).replace(/[\s,.;:–-]+$/, "")}…`; } function tagChips(tags) { return (tags || []).map((tag) => ` `).join(""); } function badges(role, { seniority = false } = {}) { const words = [role.remote, role.function, seniority ? role.seniority : ""].filter(Boolean); return (role.closed_at ? `closed` : "") + words.map((w) => `${esc(w)}`).join(""); } function drawRow(el, role) { const scored = role.score !== null && role.score !== undefined; const pct = scored ? Math.round(Math.min(1, Math.max(0, role.score)) * 100) : 0; const text = excerpt(role); el.innerHTML = `
${scored ? pct : ""}
${esc(role.title || "(untitled)")}
${role.company ? `${esc(role.company)}` : ""} ${role.place ? `${esc(role.place)}` : ""} ${badges(role)} ${ago(role.first_seen)} ${role.gated_reason ? `${esc(role.gated_reason)}` : ""} ${tagChips(role.tags)}
${text ? `

${esc(text)}

` : ""}
`; el.querySelector(".actions").appendChild(judgeButtons(role, () => paintRow(el, role))); // Plain click reads it here; a modified or middle click still gets the // real link, which is this same page with the role open. el.querySelector(".headline").onclick = (e) => { if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || e.button !== 0) return; e.preventDefault(); openReader(role.uid); }; // A tag on a role is also the fastest way to ask for more like it. el.querySelectorAll(".tag").forEach((b) => { b.onclick = () => toggleTag(b.dataset.tag); }); } /* A passed role and a hidden company's are dimmed, never dropped: the pass has to stay visible to be undone. */ function paintRow(el, role) { const company = companies.get(role.company_key); el.dataset.read = String(Boolean(role.read_at)); el.classList.toggle("muted", Boolean(company && company.affinity === -1)); el.classList.toggle("passed", role.vote === -1); el.classList.toggle("gated", Boolean(role.gated_reason)); } function makeRow() { const el = document.createElement("article"); el.className = "row"; return el; } function fillRow(el, { role, i }) { if (el.role !== role) { el.role = role; drawRow(el, role); } el.dataset.uid = role.uid; el.dataset.idx = String(i); el.dataset.current = String(i === state.selected); el.dataset.open = String(role.uid === state.readingUid); paintRow(el, role); el.querySelectorAll(".tag").forEach((b) => { b.setAttribute("aria-pressed", String(state.filter.tags.has(b.dataset.tag))); }); } const rowAt = (i) => $(`#roles-list .row[data-idx="${i}"]`); function renderFeed() { // Which order the list is in, for the stylesheet: under Newest first the // score gutter goes, since the score is not what put the row where it is. $("#list").dataset.sort = sortShown(); sync($("#roles-list"), state.items.map((role, i) => [role.uid, { role, i }]), makeRow, fillRow); const empty = $("#feed-empty"); empty.hidden = !(state.loaded && !state.items.length); if (!empty.hidden) { const f = state.filter; const filtered = state.q || f.tags.size || f.period !== "all" || !f.showRead || f.company.trim() || f.place.trim() || f.function || f.remote || f.judged; empty.innerHTML = filtered ? `

Nothing matches

No open role fits these filters. and start again.

` : `

No roles yet

Nothing has been pulled yet. Runs starts one; Job boards and Company boards decide what it brings in.

`; 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. 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.`; } // ----------------------------------------------------------- the reader // Reading happens in a third column rather than on a page of its own, so // voting stays one keystroke away from the text being judged. function openReader(uid) { if (!uid) return; const reading = Boolean(state.readingUid); navigate(pathFor(uid), { replace: reading }); if (!reading) state.pushedReader = true; } // Every way of closing goes through the back button rather than around it, // so the entry `openReader` pushed is popped by the close that matches it. A // role arrived at directly (a link, a reload) has no entry of ours under it, // so its list replaces it instead of leaving the app. function closeReader() { if (state.pushedReader) history.back(); else navigate(pathFor(null), { replace: true }); } // What `route` does when the path names a role: the pane, and the fetch. async function showReader(uid) { if (!state.readingUid) state.listY = window.scrollY; // Drop the last role first, or the loading render paints its text for as // long as the fetch takes. state.reading = null; state.readingUid = uid; const idx = state.items.findIndex((r) => r.uid === uid); if (idx >= 0) state.selected = idx; // Three columns need room. Below that the rail yields, since choosing // what to read is done the moment reading starts. if (state.railOpen && window.innerWidth < 1500) { state.railOpen = false; state.railAutoShut = true; renderRail(); } renderReader({ loading: true }); renderFeed(); rowAt(state.selected)?.scrollIntoView({ block: "nearest" }); markRead(uid); try { const role = await api(`/api/roles/${encodeURIComponent(uid)}`); if (state.readingUid !== uid) return; // moved on before this landed state.reading = role; renderReader(); } catch (err) { if (state.readingUid === uid) renderReader({ error: err.detail || String(err) }); } } // What `route` does when the path no longer names a role. function shutReader() { state.pushedReader = false; state.reading = null; state.readingUid = null; state.summarising = null; if (state.railAutoShut) { state.railOpen = true; state.railAutoShut = false; } renderReader(); renderFeed(); renderRail(); document.title = "Roles — roledesk"; // The feed was not on screen while the reader was (narrow), or was a // pane of its own that shortened the page (wide), and the page lost its // place with it. Back to where it was, then as far as the row the keys // moved to. window.scrollTo(0, state.listY); rowAt(state.selected)?.scrollIntoView({ block: "nearest" }); } async function markRead(uid) { const item = state.items.find((r) => r.uid === uid); if (item && item.read_at) return; if (item) { item.read_at = new Date().toISOString(); renderFeed(); } try { const role = await api(`/api/roles/${encodeURIComponent(uid)}/read`, { method: "POST" }); if (item && role) item.read_at = role.read_at; } catch (err) { /* toasted by api() */ } } function salary(r) { const n = (v) => number.format(v); const unit = r.currency ? `${r.currency} ` : ""; if (r.salary_min && r.salary_max && r.salary_min !== r.salary_max) { return `${unit}${n(r.salary_min)}–${n(r.salary_max)}`; } if (r.salary_min || r.salary_max) { const one = r.salary_min || r.salary_max; return r.salary_min ? `From ${unit}${n(one)}` : `Up to ${unit}${n(one)}`; } return ""; } function host(url) { try { return new URL(url).host.replace(/^www\./, ""); } catch (e) { return ""; } } /* Plain text in paragraphs: a fetched page keeps its line breaks, and a board's description is one long line, which stays one paragraph. */ function paragraphs(text) { return text.split(/\n+/).map((p) => p.trim()).filter(Boolean) .map((p) => `

${esc(p)}

`).join(""); } function renderReader({ loading = false, error = "" } = {}) { const el = $("#reader"); const open = Boolean(state.readingUid); el.hidden = !open; const want = open ? "open" : "shut"; if (document.body.dataset.reader !== want) { document.body.dataset.reader = want; renderRail(); } if (!open) { el.replaceChildren(); return; } // The list row is already in memory, and a list row is the whole role, so // the pane paints from it at once and the fetch only brings it up to date. const stub = state.items.find((r) => r.uid === state.readingUid); const r = state.reading || stub || {}; const same = el.dataset.uid === state.readingUid; const scrolled = same ? el.querySelector(".reader-body")?.scrollTop || 0 : 0; el.dataset.uid = state.readingUid; if (r.title) document.title = `${r.title} — roledesk`; const out = safeUrl(r.original_url); const text = (r.article_text || r.description || "").trim(); const body = error ? `

This role could not be loaded: ${esc(error)}

` : !r.uid ? `

Loading…

` : text ? paragraphs(text) : `

The board gave no description for this one.

`; const pay = salary(r); const waiting = state.summarising === state.readingUid; const teaser = r.uid && !r.article_text && out && (r.description || "").length < TEASER; el.innerHTML = `
${out ? `↗` : ""}
${r.company ? `${esc(r.company)}` : ""} ${r.place ? `${esc(r.place)}` : ""} ${r.first_seen ? `${ago(r.first_seen)}` : ""} ${badges(r, { seniority: true })} ${tagChips(r.tags)}

${esc(r.title || "")}

${pay ? `

${esc(pay)}

` : ""} ${r.summary ? `

Summary

${esc(r.summary)}

` : ""}
${r.uid && !r.summary && !waiting ? `` : ""} ${teaser ? `` : ""} ${waiting ? "The summary appears here when it is ready." : ""}
${body}
${out ? `

Read it on ${esc(host(out) || "the board")} ↗

` : ""}
`; if (r.uid) el.querySelector(".judge").appendChild(judgeButtons(r)); renderAffinity(el.querySelector(".affinity-slot"), r); el.querySelector(".close").onclick = () => closeReader(); el.querySelector(".step-prev").onclick = () => move(-1); el.querySelector(".step-next").onclick = () => move(1); el.querySelectorAll(".tag").forEach((b) => { b.onclick = () => toggleTag(b.dataset.tag); }); el.querySelector('[data-tool="summarise"]')?.addEventListener("click", (e) => summarise(e.currentTarget)); el.querySelector('[data-tool="fetch"]')?.addEventListener("click", (e) => fetchText(e.currentTarget)); el.querySelector(".reader-out a")?.addEventListener("click", () => markRead(r.uid)); el.querySelector(".reader-body").scrollTop = scrolled; } /* The company's ★ ▲ ⊘, the one place a company is judged outside the Companies page. A company seen only through a search has no row of its own to judge. A change dims or undims its rows in the feed. */ function renderAffinity(slot, r) { const company = companies.get(r.company_key); if (!company) { slot.replaceChildren(); return; } slot.replaceChildren(affinityControl(r.company_key, company.affinity, () => { renderAffinity(slot, r); renderFeed(); })); } /* The answer, into the role on screen and into its row, whose excerpt is the summary once there is one. */ function merge(updated) { if (!updated || updated.uid !== state.readingUid) return; if (state.reading) Object.assign(state.reading, updated); else state.reading = updated; const item = state.items.find((x) => x.uid === updated.uid); if (item) { Object.assign(item, { summary: updated.summary, article_text: updated.article_text }); const row = $(`#roles-list .row[data-uid="${CSS.escape(updated.uid)}"]`); if (row) row.role = null; // drawn again from the new text renderFeed(); } renderReader(); } async function busy(button, label, work) { const was = button.textContent; button.disabled = true; button.textContent = label; try { return await work(); } catch (err) { return null; // toasted by api() } finally { button.disabled = false; button.textContent = was; } } /* A search role's description is a teaser of a couple of hundred characters; this fetches the posting once and keeps it. */ async function fetchText(button) { const uid = state.readingUid; const role = await busy(button, "Fetching…", () => api(`/api/roles/${encodeURIComponent(uid)}/text`, { method: "POST" })); if (role) merge(role); } /* Queued rather than done at once: ask for the role again until the summary is there, for two minutes, and stop as soon as the reader is on another role. */ async function summarise(button) { const uid = state.readingUid; const job = await busy(button, "Summarising…", () => api(`/api/roles/${encodeURIComponent(uid)}/summarise`, { method: "POST" })); if (!job || state.readingUid !== uid) return; state.summarising = uid; renderReader(); for (let i = 0; i < 30 && state.summarising === uid; i++) { await new Promise((resolve) => setTimeout(resolve, 4000)); if (state.summarising !== uid) return; let fresh; try { fresh = await api(`/api/roles/${encodeURIComponent(uid)}`); } catch (err) { break; } if (fresh.summary) { state.summarising = null; merge(fresh); return; } } if (state.summarising === uid) { state.summarising = null; renderReader(); } } // ------------------------------------------------------------ the keys function move(delta) { if (!state.items.length) return; state.selected = Math.max(0, Math.min(state.items.length - 1, state.selected + delta)); renderFeed(); rowAt(state.selected)?.scrollIntoView({ block: "nearest" }); // With the reader open, j/k walks the list and the reader follows. if (state.readingUid) openReader(state.items[state.selected].uid); } /** Press one of judge.js's buttons for the role in hand: the reader's when it is open, else the selected row's. One control, whichever way in. */ function judge(cls) { const box = state.readingUid ? $("#reader .reader-bar .judge") : rowAt(state.selected)?.querySelector(".actions"); box?.querySelector(`.${cls}`)?.click(); } function openOriginal() { const uid = state.readingUid || state.items[state.selected]?.uid; const role = state.reading?.uid === uid ? state.reading : state.items.find((r) => r.uid === uid); const url = safeUrl(role?.original_url); if (!url) return; window.open(url, "_blank", "noopener"); markRead(uid); } document.addEventListener("keydown", (e) => { // Every shortcut is a bare keypress, so a chord belongs to the browser: // ctrl+C must copy, not clear the filters. Shift is not in the list, // since S arrives with it held. if (e.ctrlKey || e.metaKey || e.altKey) return; const tag = e.target.tagName; if (tag === "INPUT" || tag === "TEXTAREA" || e.target.isContentEditable) { if (e.key === "Escape") { if (e.target.id === "search") { e.target.value = ""; setSearch(""); } e.target.blur(); } return; } // A focused select takes letters as type-ahead. if (tag === "SELECT") return; // Enter on a focused button or link is that control's. if (e.key === "Enter" && e.target.closest("button, a, summary")) return; const current = state.items[state.selected]; const map = { j: () => move(1), k: () => move(-1), u: () => judge("up"), n: () => judge("mid"), d: () => judge("down"), S: () => judge("star"), Enter: () => (state.readingUid ? closeReader() : current && openReader(current.uid)), Escape: () => { if (overlayRail() && state.railOpen) toggleRail(); else if (state.readingUid) closeReader(); }, o: openOriginal, "/": () => $("#search").focus(), f: toggleRail, c: clearFilters, }; if (map[e.key]) { e.preventDefault(); map[e.key](); } }); // ---------------------------------------------------------- the router // / the feed // /roles/ a role, open over the feed // // The query string is the filter's and rides along unchanged. function parseRoute(path) { const role = path.match(/^\/roles\/([^/]+)$/); return { uid: role ? decodeURIComponent(role[1]) : null }; } function pathFor(uid) { return uid ? `/roles/${encodeURIComponent(uid)}` : "/"; } function navigate(path, { replace = false } = {}) { if (path !== location.pathname) { history[replace ? "replaceState" : "pushState"](null, "", path + location.search); } route(); } // Make the screen match the path. Called on every navigation and on the // back and forward buttons; stepping from one role to the next does not // reload the list under it. function route() { const to = parseRoute(location.pathname); if (to.uid) { if (to.uid !== state.readingUid) showReader(to.uid); } else if (state.readingUid) { shutReader(); } } // The system back gesture, which on a phone is the reflex Escape is here. window.addEventListener("popstate", route); // ------------------------------------------------ back from another page function keep() { try { sessionStorage.setItem(KEPT, JSON.stringify({ url: location.pathname + location.search, count: state.items.length, y: window.scrollY, rail: state.railOpen, })); } catch (err) { /* private mode: back is a fresh list, which is fine */ } } function kept() { const [entry] = performance.getEntriesByType("navigation"); if (!entry || !["back_forward", "reload"].includes(entry.type)) return null; try { const was = JSON.parse(sessionStorage.getItem(KEPT) || "null"); return was && was.url === location.pathname + location.search ? was : null; } catch (err) { return null; } } // The header's height, for everything pinned under it: the rail, the // reader, the scrim. It is not a constant (44px touch targets make the // header taller), and everything pinned to a stale number slides under it. function measureChrome() { const header = $("header.top"); document.documentElement.style.setProperty("--chrome", `${header.offsetHeight}px`); } function wire() { $("#rail-toggle").addEventListener("click", toggleRail); $("#scrim").addEventListener("click", toggleRail); $("#show-read").addEventListener("click", () => setFilter({ showRead: !state.filter.showRead })); $("#agent").addEventListener("change", (e) => { const id = e.target.value; setFilter(id ? { sort: "score", agent: Number(id) } : { sort: "time" }); }); $("#period").innerHTML = Object.entries(PERIODS).map(([key, p]) => ``).join(""); $("#period").addEventListener("change", (e) => setFilter({ period: e.target.value })); $("#clear-tags").addEventListener("click", () => { state.filter.tags.clear(); setFilter({}); }); const typed = debounce(() => setFilter({}), 300); for (const key of ["company", "place"]) { $(`#f-${key}`).addEventListener("input", (e) => { state.filter[key] = e.target.value; typed(); }); } for (const key of ["function", "remote", "judged"]) { $(`#f-${key}`).addEventListener("change", (e) => setFilter({ [key]: e.target.value })); } $("#f-show-muted").addEventListener("change", (e) => setFilter({ showMuted: e.target.checked }, { counts: true })); $("#f-gated").addEventListener("change", (e) => setFilter({ gated: e.target.checked })); const searched = debounce((value) => setSearch(value.trim()), 250); $("#search").addEventListener("input", (e) => searched(e.target.value)); $("#search").value = state.q; // The rail follows the layout: beside the feed when there is room, put // away when it would be an overlay. narrow.addEventListener("change", () => { state.railOpen = !narrow.matches; state.railAutoShut = false; renderRail(); }); measureChrome(); new ResizeObserver(measureChrome).observe($("header.top")); new IntersectionObserver((entries) => { if (entries.some((e) => e.isIntersecting)) loadFeed({ append: true }); }, { rootMargin: "600px" }).observe($("#feed-end")); // Kept on the way out, whichever way that is, so back finds it. window.addEventListener("pagehide", keep); // Back from another tab without a reload (the back/forward cache): the // rows are the ones left, but a vote or a star may have changed there. window.addEventListener("pageshow", async (e) => { if (!e.persisted) return; const y = window.scrollY; await Promise.all([loadTracked(), loadCompanies()]).catch(() => {}); await loadFeed({ keep: state.items.length }); if (state.readingUid) renderReader(); window.scrollTo(0, y); }); } document.addEventListener("DOMContentLoaded", async () => { readUrl(); const was = kept(); if (was && !narrow.matches) state.railOpen = was.rail; wire(); renderRail(); renderActive(); try { await Promise.all([loadCompanies(), loadTracked(), loadAgents()]); } catch (err) { return; } renderRail(); renderActive(); loadFilters().catch(() => {}); route(); await loadFeed({ keep: was ? was.count : 0 }); if (was && !state.readingUid) window.scrollTo(0, was.y || 0); }); })();