web: run history list, filter and sort (R1/R2)

Day-grouped run list with sticky day headers (Today / Yesterday / d MMM
yyyy / Unknown date), a usage roll-up block, the app's row hierarchy and
a bounded filter/sort menu — mirroring RunHistoryScreen.kt, ListFilter.kt
and ListSort.kt. New pure helpers live in src/runs.js with focused unit
tests; app.js keeps the wiring and sets server strings with textContent.

R1 done, R2 partial: no per-row "needs you" mark exists in the Android
app; its wording is deferred to R15 (separate attention surface).
This commit is contained in:
2026-10-19 02:50:51 +01:00
parent 4721b8af10
commit 849a184561
6 changed files with 1601 additions and 48 deletions
+343 -39
View File
@@ -4,6 +4,26 @@
import { PipelinesClient } from "./client.js";
import { PipelinesRepository } from "./repository.js";
import { validateServerUrl, resolveArtifactUrl } from "./serverUrl.js";
import {
RUN_STATES,
RUN_TIME_RANGES,
RUN_SORTS,
DEFAULT_RUN_SORT,
runStateOf,
runIdentity,
versionLabel,
progressText,
metaText,
formatDuration,
localDayKey,
filterRuns,
groupRunsByDay,
runComparator,
pipelineFilterOptions,
runListEntries,
defaultRunFilters,
runFiltersActiveCount,
} from "./runs.js";
const STORAGE_KEY = "pipelines.web.serverUrl.v2";
@@ -45,10 +65,20 @@ const state = {
selectedRunId: null,
loading: false,
error: "",
runFilters: defaultRunFilters(),
runSort: DEFAULT_RUN_SORT,
openMenu: null,
};
let runPoll = null;
// One shared live clock for the runs list: it ticks only while a shown run is
// executing, and each running row reads its elapsed from it rather than starting
// a timer of its own. Elapsed is derived from the server's start timestamp, so
// it stays correct after a reconnect; a finished history never ticks.
let listClock = null;
let listNow = Date.now();
// ---------------------------------------------------------------------------
// DOM helpers
// ---------------------------------------------------------------------------
@@ -181,6 +211,8 @@ function renderContent() {
}
nodes.push(split);
content.replaceChildren(...nodes);
if (state.view === "runs") refreshListClock();
else stopListClock();
}
function tabButton(view, label) {
@@ -265,52 +297,294 @@ function renderPipelineDetail() {
}
function renderRunList() {
const list = h("div", { class: "list" });
if (state.usage) {
list.append(
h(
"div",
{ class: "usage" },
h("span", { text: `${state.usage.total} total` }),
h("span", { class: "ok", text: `${state.usage.succeeded} succeeded` }),
h("span", { class: "bad", text: `${state.usage.failed} failed` }),
h("span", { class: "warn", text: `${state.usage.active} active` }),
),
);
}
const pane = h("div", { class: "list runs" });
pane.append(renderRunToolbar());
const scroll = h("div", { class: "run-scroll" });
if (state.loading && !state.runs.length) {
list.append(h("div", { class: "muted pad", text: "Loading…" }));
return list;
scroll.append(h("div", { class: "muted pad", text: "Loading…" }));
pane.append(scroll);
return pane;
}
if (!state.runs.length) {
list.append(h("div", { class: "muted pad", text: "No runs." }));
return list;
const filters = state.runFilters;
const today = localDayKey(new Date());
const filtered = filterRuns(state.runs, filters, today);
const groups = groupRunsByDay(filtered, today, undefined, runComparator(state.runSort));
const entries = runListEntries(
state.usage,
state.runs.length === 0,
filtered.length === 0 && state.runs.length > 0,
groups,
"",
);
for (const entry of entries) {
switch (entry.kind) {
case "usage":
scroll.append(renderUsage(entry.usage));
break;
case "empty":
scroll.append(renderEmptyState(entry));
break;
case "day":
scroll.append(h("div", { class: "day-header", text: entry.label }));
break;
case "run":
scroll.append(renderRunRow(entry.run));
break;
case "error":
scroll.append(h("div", { class: "run-list-error", text: entry.message }));
break;
}
}
for (const r of state.runs) {
list.append(
pane.append(scroll);
return pane;
}
function renderUsage(usage) {
const metrics = h("div", { class: "metrics" });
metrics.append(metric("Total", String(usage.total ?? 0), "total"));
if ((usage.average_seconds ?? 0) > 0) {
metrics.append(metric("Average", formatDuration(usage.average_seconds), "average"));
}
metrics.append(metric("Succeeded", String(usage.succeeded ?? 0), "succeeded"));
metrics.append(metric("Failed", String(usage.failed ?? 0), "failed"));
metrics.append(metric("Canceled", String(usage.canceled ?? 0), "canceled"));
metrics.append(metric("Interrupted", String(usage.interrupted ?? 0), "interrupted"));
metrics.append(metric("Active", String(usage.active ?? 0), "active"));
return metrics;
}
function metric(label, value, cls) {
return h(
"div",
{ class: `metric metric-${cls}` },
h("span", { class: "metric-value", text: value }),
h("span", { class: "metric-label", text: label }),
);
}
function renderEmptyState(entry) {
const wrap = h("div", { class: "empty-state" }, h("span", { text: entry.message }));
if (entry.actionLabel) {
wrap.append(h("button", { class: "ghost", text: entry.actionLabel, onclick: clearRunFilters }));
}
return wrap;
}
/**
* One run row, in the app's exact hierarchy: status chip (+ spinner while
* executing); primary line = stored title else pipeline name, carrying the
* version chip when there is no title; the pipeline name + version chip on a
* second line only when a title exists; the progress line; the meta line; and
* the diagnostic line, in the error colour only on a failure. Every
* server-provided string is set with textContent.
*/
function renderRunRow(run) {
const status = runStateOf(run.status);
const identity = runIdentity(run.title, run.name);
const row = h("button", {
class: `row run-row${state.selectedRunId === run.id ? " selected" : ""}`,
onclick: () => selectRun(run.id),
});
const head = h("span", { class: "run-row-head" });
head.append(h("span", { class: `chip chip-${status}`, text: status }));
if (run.executing) head.append(h("span", { class: "spinner", "aria-hidden": "true" }));
head.append(h("span", { class: "run-row-title", text: identity.label }));
if (identity.pipeline == null) head.append(versionChip(run.version));
row.append(head);
if (identity.pipeline != null) {
row.append(
h(
"button",
{
class: `row${state.selectedRunId === r.id ? " selected" : ""}`,
onclick: () => selectRun(r.id),
},
h(
"span",
{ class: "row-head" },
h("span", { class: "row-title", text: r.title || r.name || `run ${r.id}` }),
h("span", { class: statusClass(r.status), text: r.status || "unknown" }),
),
h(
"span",
{ class: "row-meta" },
`#${r.id} · ${fmtTime(r.created_at)} · `,
isExecuting(r) ? h("em", { text: fmtDuration(r.created_at, "") }) : fmtDuration(r.created_at, r.finished_at),
),
r.diagnostic ? h("span", { class: "row-diag", text: r.diagnostic }) : null,
"span",
{ class: "run-row-pipeline" },
h("span", { class: "run-row-pipeline-name", text: identity.pipeline }),
versionChip(run.version),
),
);
}
return list;
row.append(h("span", { class: "run-row-progress", text: progressText(run) }));
row.append(
h("span", {
class: "run-row-meta",
"data-run-id": String(run.id),
text: metaText(run, listNow),
}),
);
if (String(run.diagnostic ?? "").trim()) {
row.append(
h("span", {
class: `run-row-diag${status === "failed" ? " error" : ""}`,
text: run.diagnostic,
}),
);
}
return row;
}
function versionChip(version) {
return h("span", { class: "version-chip", text: versionLabel(version) });
}
function renderRunToolbar() {
const activeCount = runFiltersActiveCount(state.runFilters);
const filterLabel = activeCount > 0 ? `Filter (${activeCount})` : "Filter";
const sortLabel = (RUN_SORTS.find((s) => s.value === state.runSort) ?? RUN_SORTS[0]).label;
const toolbar = h("div", { class: "run-toolbar" });
toolbar.append(
h(
"div",
{ class: "menu-anchor" },
h("button", {
id: "runFilterBtn",
class: `ghost filter-btn${activeCount > 0 ? " active" : ""}`,
title: activeCount > 0 ? `${activeCount} active filter${activeCount === 1 ? "" : "s"}` : "Filter runs",
text: filterLabel,
"data-active-count": String(activeCount),
onclick: () => toggleMenu("filter"),
}),
state.openMenu === "filter" ? renderFilterMenu() : null,
),
h(
"div",
{ class: "menu-anchor" },
h("button", {
id: "runSortBtn",
class: "ghost sort-btn",
title: "Sort runs",
text: `Sort: ${sortLabel}`,
onclick: () => toggleMenu("sort"),
}),
state.openMenu === "sort" ? renderSortMenu() : null,
),
h("span", { class: "spacer" }),
);
return toolbar;
}
function renderFilterMenu() {
const filters = state.runFilters;
const menu = h("div", { class: "menu filter-menu", id: "runFilterMenu" });
menu.append(h("div", { class: "menu-section", text: "Status" }));
for (const status of RUN_STATES) {
menu.append(
filterCheck(status, filters.statuses.has(status), () => toggleStatusFilter(status), {
"data-status": status,
}),
);
}
menu.append(h("div", { class: "menu-divider" }));
menu.append(h("div", { class: "menu-section", text: "Pipeline" }));
menu.append(
filterCheck("Any pipeline", filters.pipelineId == null, () => setPipelineFilter(null), {
"data-pipeline": "any",
}),
);
for (const option of pipelineFilterOptions(state.runs)) {
menu.append(
filterCheck(option.name, filters.pipelineId === option.id, () => setPipelineFilter(option.id), {
"data-pipeline": String(option.id),
}),
);
}
menu.append(h("div", { class: "menu-divider" }));
menu.append(h("div", { class: "menu-section", text: "Time range" }));
for (const range of RUN_TIME_RANGES) {
menu.append(
filterCheck(range.label, filters.timeRange === range.value, () => setTimeRangeFilter(range.value), {
"data-time": range.value,
}),
);
}
menu.append(
h(
"div",
{ class: "menu-actions" },
h("button", { class: "ghost", text: "Clear filters", onclick: clearRunFilters }),
h("button", { class: "ghost", text: "Done", onclick: closeMenu }),
),
);
return menu;
}
function filterCheck(label, checked, onclick, data = {}) {
return h(
"label",
{ class: "filter-check" },
h("input", {
type: "checkbox",
checked: checked ? "checked" : null,
onchange: onclick,
...data,
}),
h("span", { text: label }),
);
}
function renderSortMenu() {
const menu = h("div", { class: "menu sort-menu", id: "runSortMenu" });
for (const option of RUN_SORTS) {
menu.append(
h("button", {
class: `menu-item${state.runSort === option.value ? " selected" : ""}`,
text: option.label,
onclick: () => {
state.runSort = option.value;
closeMenu();
},
}),
);
}
menu.append(h("div", { class: "menu-divider" }));
menu.append(
h("button", {
class: "menu-item",
text: "Reset",
onclick: () => {
state.runSort = DEFAULT_RUN_SORT;
closeMenu();
},
}),
);
return menu;
}
function toggleStatusFilter(status) {
const next = new Set(state.runFilters.statuses);
if (next.has(status)) next.delete(status);
else next.add(status);
state.runFilters = { ...state.runFilters, statuses: next };
renderContent();
}
function setPipelineFilter(pipelineId) {
state.runFilters = { ...state.runFilters, pipelineId };
closeMenu();
}
function setTimeRangeFilter(timeRange) {
state.runFilters = { ...state.runFilters, timeRange };
closeMenu();
}
function clearRunFilters() {
state.runFilters = defaultRunFilters();
closeMenu();
}
function toggleMenu(name) {
state.openMenu = state.openMenu === name ? null : name;
renderContent();
}
function closeMenu() {
state.openMenu = null;
renderContent();
}
function renderRunDetail() {
@@ -509,6 +783,35 @@ function stopRunPoll() {
}
}
/**
* (Re)start the shared runs-list clock: it ticks once a second only while a
* shown run is executing, updating each running row's meta line in place (never
* a full re-render, so an open filter/sort menu is not torn down). The elapsed
* value is derived from the run's server start timestamp, so it survives a
* reconnect.
*/
function refreshListClock() {
stopListClock();
listNow = Date.now();
if (state.view === "runs" && state.runs.some((run) => run.executing)) {
listClock = setInterval(() => {
listNow = Date.now();
for (const node of document.querySelectorAll(".run-row-meta[data-run-id]")) {
const id = Number(node.getAttribute("data-run-id"));
const run = state.runs.find((candidate) => candidate.id === id);
if (run && run.executing) node.textContent = metaText(run, listNow);
}
}, 1000);
}
}
function stopListClock() {
if (listClock) {
clearInterval(listClock);
listClock = null;
}
}
// ---------------------------------------------------------------------------
// Boot
// ---------------------------------------------------------------------------
@@ -523,6 +826,7 @@ client.addEventListener("state", (event) => {
}
if (next.kind !== "connected" && previousKind === "connected") {
stopRunPoll();
stopListClock();
}
render();
});