web: add omni-search results and routing (S1/S2)
This commit is contained in:
+8
-2
@@ -65,8 +65,14 @@ re-composed.
|
||||
## Search
|
||||
| # | Feature | Protocol | Status |
|
||||
| --- | --- | --- | --- |
|
||||
| S1 | Omni-search across pipelines, versions, runs, steps, fields, artifacts | `search` | todo |
|
||||
| S2 | Result routing (open the pipeline, run, stage, artifact) | — | todo |
|
||||
| S1 | Omni-search across pipelines, versions, runs, steps, fields, artifacts | `search` | done — the top bar's `Search` control opens a full-width panel under it (field autofocused, placeholder `Search pipelines, runs and artifacts`, a `Close search` control; opening and closing leave the current view, selection and loaded data untouched, and Escape closes the field). One flat result list with no kind grouping, over a controls row: the kind select (`All kinds`/`Pipelines`/`Runs`/`Steps`/`Fields`/`Artifacts`/`Versions`), the sort select (`Relevance`/`Newest first`/`Name`), the one-line `{Kind} · {Sort}` summary and a `Clear filter` reset. The request is exactly `{type:"search",search:{query,kind,limit:0}}` — the server's own default cap, never above `SearchMaxLimit` 200 — debounced 250 ms after the last keystroke with Enter sending at once; a blank query clears locally with no request; the previous results stay visible (a thin progress bar above them) while a newer query loads and a stale reply is dropped by token; the first load shows the spinner and `Searching…`; an error takes precedence over the results. Failure copy is `AppViewModel`'s: a rejection naming an unknown command, or an older server's reply without `search_results`, reads `This server does not support search. Update the Pipelines server, then try again.` and any other failure carries the server's own text. Row text and blank fallbacks mirror `OmniSearchResults.searchRow` (a field hit's snippet emphasises the first case-insensitive query occurrence, never via `innerHTML`) and the empty state keeps Android's `No matches for "{query}".` / `No {kind} match "{query}".`. Captured 2026-10-19: `captures/01-search-results.png` (flat mixed list for the query `plan`, the controls row and summary `All kinds · Relevance`), `captures/02-search-kind-filter.png` (the `Pipelines` filter narrowing the list and the summary to `Pipelines · Relevance`) |
|
||||
| S2 | Result routing (open the pipeline, run, stage, artifact) | — | done — every selection closes and clears the search first, then routes through the page's existing navigation: a pipeline/version hit opens the pipeline detail at the result version (version 0 = latest); a run hit opens the run detail; a text hit opens the run-detail tab holding the match, resolved from the hit's `matched_field` (`input` → Input, `output` → Output, else Summary — the browser item's deliberate rule, not the recorded field name); a step or artifact hit opens the recorded visit's stage pane (the zero-based visit index within the stage, falling back to the plain run detail when the visit cannot be located); an unknown/absent payload is read-only and never navigates. Captured 2026-10-19, each with the routed destination asserted in the smoke run: `captures/03-search-route-pipeline.png` (`pipeline:24:v5` → `Plan and land` detail), `captures/04-search-route-run.png` (`run:457` → Runs detail), `captures/05-search-route-field.png` (`run:458:3`, `matched_field input` → the Input tab active), `captures/06-search-route-step.png` (`run:457:1` → the `planner` visit stage pane), `captures/07-search-route-artifact.png` (`/artifacts/355/2/…` → the `implementer` visit pane), `captures/08-search-route-version.png` (`pipeline:22:v6` → the `Server` detail) |
|
||||
|
||||
Two wording decisions in Search, recorded here as the app-authoritative choices:
|
||||
the controls summary is exactly `{Kind} · {Sort}` (the browser item's wording, with
|
||||
none of the Android panel's ` (in hand)` note), and the kind-filtered empty state
|
||||
keeps Android's invariant `No {kind} match "{query}".` — the same sentence shape
|
||||
the pipeline list already carries — rather than a pluralised verb.
|
||||
|
||||
## Chat
|
||||
| # | Feature | Protocol | Status |
|
||||
|
||||
+437
-8
@@ -133,6 +133,25 @@ import {
|
||||
runChangesHeader,
|
||||
runChangesNote,
|
||||
} from "./changes.js";
|
||||
import {
|
||||
DEFAULT_SEARCH_KIND,
|
||||
DEFAULT_SEARCH_SORT,
|
||||
SEARCH_DEBOUNCE_MS,
|
||||
SEARCH_KINDS,
|
||||
SEARCH_SORTS,
|
||||
SearchSequencer,
|
||||
filterSearchResults,
|
||||
resolveRunTarget,
|
||||
searchControlsSummary,
|
||||
searchFailureText,
|
||||
searchPanelBody,
|
||||
searchPanelProgress,
|
||||
searchQuerySendable,
|
||||
searchResultKindLabel,
|
||||
searchRow,
|
||||
searchTarget,
|
||||
sortSearchResults,
|
||||
} from "./search.js";
|
||||
|
||||
const STORAGE_KEY = "pipelines.web.serverUrl.v2";
|
||||
|
||||
@@ -209,6 +228,19 @@ const state = {
|
||||
runSections: new Set(),
|
||||
runStagePane: null,
|
||||
runStageSections: new Set(),
|
||||
// Omni-search (S1/S2): the field/panel state, kept beside the view it never
|
||||
// changes, plus the pure debounce/stale-token sequencer. Opening or closing the
|
||||
// search leaves state.view, the selection and the loaded data untouched.
|
||||
searchOpen: false,
|
||||
searchQuery: "",
|
||||
searchKind: DEFAULT_SEARCH_KIND,
|
||||
searchSort: DEFAULT_SEARCH_SORT,
|
||||
searchResults: [],
|
||||
searchLoading: false,
|
||||
searchError: "",
|
||||
searchLoaded: false,
|
||||
searchFocusPending: false,
|
||||
searchSequencer: new SearchSequencer(),
|
||||
};
|
||||
|
||||
let runPoll = null;
|
||||
@@ -256,11 +288,20 @@ function isExecuting(run) {
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const header = h("header", { class: "topbar" });
|
||||
// The full-width omni-search panel sits directly under the top bar (and so under
|
||||
// the search control that lives in it), above the connection banner so it can
|
||||
// never be mistaken for a status strip.
|
||||
const searchHost = h("div", { id: "searchHost", class: "search-host" });
|
||||
// The persistent connection banner sits in normal document flow directly under
|
||||
// the header (never fixed/overlaying), so it can never cover the content.
|
||||
const connBanner = h("div", { id: "connBanner", class: "conn-banner", hidden: true });
|
||||
const content = h("main", { id: "content" });
|
||||
document.body.append(header, connBanner, content);
|
||||
document.body.append(header, searchHost, connBanner, content);
|
||||
|
||||
// The pending debounce timer and the edit it belongs to. Both are dropped the
|
||||
// moment the query is sent, cleared or superseded.
|
||||
let searchTimer = null;
|
||||
let searchEdit = null;
|
||||
|
||||
/** Whether the URL field currently holds a usable endpoint for Reconnect. */
|
||||
function endpointConfigured() {
|
||||
@@ -270,6 +311,7 @@ function endpointConfigured() {
|
||||
function renderHeader() {
|
||||
const info = bannerState(state.connection, { hasEndpoint: endpointConfigured() });
|
||||
const controls = [
|
||||
...searchHeaderControls(),
|
||||
h("input", {
|
||||
id: "url",
|
||||
type: "text",
|
||||
@@ -300,6 +342,58 @@ function renderHeader() {
|
||||
h("div", { class: "brand" }, h("strong", { text: "Pipelines" }), h("span", { class: "muted", text: "web spike" })),
|
||||
h("div", { class: "connbar" }, ...controls),
|
||||
);
|
||||
// Autofocus the field only for the render that opened it, so a later
|
||||
// connection-state re-render never steals the operator's focus.
|
||||
if (state.searchOpen && state.searchFocusPending) {
|
||||
document.getElementById("searchInput")?.focus();
|
||||
state.searchFocusPending = false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The top bar's search control: the Search button while closed, and the query
|
||||
* field with its Close control while open. The field's value is always read back
|
||||
* from `state.searchQuery`, so a re-render can never desync the two.
|
||||
*/
|
||||
function searchHeaderControls() {
|
||||
if (!state.searchOpen) {
|
||||
return [
|
||||
h("button", {
|
||||
id: "searchToggle",
|
||||
class: "ghost search-toggle",
|
||||
type: "button",
|
||||
title: "Search",
|
||||
text: "Search",
|
||||
onclick: openSearch,
|
||||
}),
|
||||
];
|
||||
}
|
||||
return [
|
||||
h("input", {
|
||||
id: "searchInput",
|
||||
class: "search-input",
|
||||
type: "text",
|
||||
placeholder: "Search pipelines, runs and artifacts",
|
||||
value: state.searchQuery,
|
||||
spellcheck: "false",
|
||||
autocomplete: "off",
|
||||
"aria-label": "Search",
|
||||
oninput: (event) => onSearchInput(event.target.value),
|
||||
onkeydown: (event) => {
|
||||
if (event.key === "Enter") {
|
||||
event.preventDefault();
|
||||
sendSearchNow();
|
||||
}
|
||||
},
|
||||
}),
|
||||
h("button", {
|
||||
id: "searchClose",
|
||||
class: "ghost search-close",
|
||||
type: "button",
|
||||
text: "Close search",
|
||||
onclick: closeSearch,
|
||||
}),
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -330,6 +424,7 @@ function connectionLabel() {
|
||||
function render() {
|
||||
renderHeader();
|
||||
renderBanner();
|
||||
renderSearch();
|
||||
renderContent();
|
||||
}
|
||||
|
||||
@@ -2249,6 +2344,337 @@ function kvMono(key, value) {
|
||||
);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Omni-search (S1/S2)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** Open the search field and ask for focus; the current view is left alone. */
|
||||
function openSearch() {
|
||||
if (state.searchOpen) return;
|
||||
state.searchOpen = true;
|
||||
state.searchError = "";
|
||||
state.searchFocusPending = true;
|
||||
renderHeader();
|
||||
renderSearch();
|
||||
}
|
||||
|
||||
/**
|
||||
* Close and clear the search: the pending debounce is dropped, an in-flight reply
|
||||
* is invalidated by recording a fresh edit, and the query, results, error and
|
||||
* loading flag are reset. The view, the selection and the loaded data are
|
||||
* deliberately untouched, so closing restores exactly the state that was on
|
||||
* screen before the search opened.
|
||||
*/
|
||||
function closeSearch() {
|
||||
cancelSearchDebounce();
|
||||
// Recording an empty edit advances the sequencer, so a reply for a request
|
||||
// still in flight can no longer be accepted.
|
||||
state.searchSequencer.edit("");
|
||||
state.searchOpen = false;
|
||||
state.searchQuery = "";
|
||||
state.searchResults = [];
|
||||
state.searchLoading = false;
|
||||
state.searchError = "";
|
||||
state.searchLoaded = false;
|
||||
state.searchFocusPending = false;
|
||||
renderHeader();
|
||||
renderSearch();
|
||||
}
|
||||
|
||||
function cancelSearchDebounce() {
|
||||
if (searchTimer) {
|
||||
clearTimeout(searchTimer);
|
||||
searchTimer = null;
|
||||
}
|
||||
searchEdit = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* A keystroke. A blank/whitespace query clears the results locally and sends
|
||||
* nothing; otherwise the previous results stay visible, the request is marked in
|
||||
* flight and the send is debounced `SEARCH_DEBOUNCE_MS` from the last keystroke.
|
||||
* Recording the edit is itself enough to drop any older reply still in flight.
|
||||
*/
|
||||
function onSearchInput(value) {
|
||||
state.searchQuery = value;
|
||||
state.searchError = "";
|
||||
cancelSearchDebounce();
|
||||
if (!searchQuerySendable(value)) {
|
||||
state.searchSequencer.edit("");
|
||||
state.searchResults = [];
|
||||
state.searchLoading = false;
|
||||
state.searchLoaded = false;
|
||||
refreshSearch();
|
||||
return;
|
||||
}
|
||||
state.searchLoading = true;
|
||||
searchEdit = state.searchSequencer.edit(value);
|
||||
refreshSearch();
|
||||
searchTimer = setTimeout(() => {
|
||||
searchTimer = null;
|
||||
const sent = state.searchSequencer.begin(searchEdit);
|
||||
if (sent) runSearch(sent);
|
||||
}, SEARCH_DEBOUNCE_MS);
|
||||
}
|
||||
|
||||
/** Send the current query at once (Enter, or a kind change), skipping the debounce. */
|
||||
function sendSearchNow() {
|
||||
const query = state.searchQuery;
|
||||
cancelSearchDebounce();
|
||||
if (!searchQuerySendable(query)) {
|
||||
state.searchSequencer.edit("");
|
||||
state.searchResults = [];
|
||||
state.searchLoading = false;
|
||||
state.searchError = "";
|
||||
state.searchLoaded = false;
|
||||
refreshSearch();
|
||||
return;
|
||||
}
|
||||
const sent = state.searchSequencer.begin(state.searchSequencer.edit(query));
|
||||
if (sent) runSearch(sent);
|
||||
}
|
||||
|
||||
/**
|
||||
* A kind-filter change: the in-hand filter is re-applied immediately so the list
|
||||
* always matches the control, and — when the query is non-blank — a fresh server
|
||||
* request is sent with the new kind. A sort change never sends a request.
|
||||
*/
|
||||
function setSearchKind(kind) {
|
||||
state.searchKind = kind;
|
||||
refreshSearch();
|
||||
if (searchQuerySendable(state.searchQuery)) sendSearchNow();
|
||||
}
|
||||
|
||||
function setSearchSort(sort) {
|
||||
state.searchSort = sort;
|
||||
refreshSearch();
|
||||
}
|
||||
|
||||
/**
|
||||
* Run one query and apply the reply only if it is still the newest edit. A reply
|
||||
* without a `search_results` payload (an older server's pong) or a rejection
|
||||
* naming an unknown command reports the app's "cannot search" sentence; any other
|
||||
* failure carries the server's own text. A stale reply is dropped entirely.
|
||||
*/
|
||||
async function runSearch(sent) {
|
||||
try {
|
||||
const reply = await repo.search(sent.query, state.searchKind);
|
||||
if (!state.searchSequencer.accepts(sent.token)) return;
|
||||
if (reply == null) {
|
||||
state.searchLoading = false;
|
||||
state.searchLoaded = true;
|
||||
state.searchError = searchFailureText(null);
|
||||
refreshSearch();
|
||||
return;
|
||||
}
|
||||
state.searchResults = Array.isArray(reply.results) ? reply.results : [];
|
||||
state.searchLoading = false;
|
||||
state.searchError = "";
|
||||
state.searchLoaded = true;
|
||||
refreshSearch();
|
||||
} catch (error) {
|
||||
if (!state.searchSequencer.accepts(sent.token)) return;
|
||||
state.searchLoading = false;
|
||||
state.searchLoaded = true;
|
||||
state.searchError = searchFailureText(error);
|
||||
refreshSearch();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Re-render the search panel's controls and results in place. Only the results
|
||||
* area, the summary and the select values are touched, so a keystroke never
|
||||
* rebuilds (and so never blurs) the query field.
|
||||
*/
|
||||
function refreshSearch() {
|
||||
const kindSelect = document.getElementById("searchKind");
|
||||
if (kindSelect) kindSelect.value = state.searchKind;
|
||||
const sortSelect = document.getElementById("searchSort");
|
||||
if (sortSelect) sortSelect.value = state.searchSort;
|
||||
const summary = document.getElementById("searchSummary");
|
||||
if (summary) summary.textContent = searchControlsSummary(state.searchKind, state.searchSort);
|
||||
const area = document.getElementById("searchResults");
|
||||
if (area) fillSearchResults(area);
|
||||
}
|
||||
|
||||
/**
|
||||
* The full-width search panel: the controls row (kind select, sort select, the
|
||||
* one-line summary and the Clear filter reset) and a bounded scrolling result
|
||||
* area. Rendered only while the search is open; the panel is one flat list, with
|
||||
* no per-kind grouping headers, matching the app.
|
||||
*/
|
||||
function renderSearch() {
|
||||
if (!state.searchOpen) {
|
||||
searchHost.replaceChildren();
|
||||
return;
|
||||
}
|
||||
const kindSelect = h(
|
||||
"select",
|
||||
{
|
||||
id: "searchKind",
|
||||
class: "search-select",
|
||||
"aria-label": "Filter results",
|
||||
onchange: (event) => setSearchKind(event.target.value),
|
||||
},
|
||||
...SEARCH_KINDS.map((option) => h("option", { value: option.value, text: option.label })),
|
||||
);
|
||||
kindSelect.value = state.searchKind;
|
||||
const sortSelect = h(
|
||||
"select",
|
||||
{
|
||||
id: "searchSort",
|
||||
class: "search-select",
|
||||
"aria-label": "Sort results in hand",
|
||||
onchange: (event) => setSearchSort(event.target.value),
|
||||
},
|
||||
...SEARCH_SORTS.map((option) => h("option", { value: option.value, text: option.label })),
|
||||
);
|
||||
sortSelect.value = state.searchSort;
|
||||
|
||||
const controls = h(
|
||||
"div",
|
||||
{ class: "search-controls" },
|
||||
h("label", { class: "search-field" }, h("span", { class: "search-field-label", text: "Kind" }), kindSelect),
|
||||
h("label", { class: "search-field" }, h("span", { class: "search-field-label", text: "Sort" }), sortSelect),
|
||||
h("span", {
|
||||
id: "searchSummary",
|
||||
class: "search-summary muted",
|
||||
text: searchControlsSummary(state.searchKind, state.searchSort),
|
||||
}),
|
||||
h("button", {
|
||||
id: "searchClearFilter",
|
||||
class: "ghost search-clear",
|
||||
type: "button",
|
||||
text: "Clear filter",
|
||||
onclick: () => setSearchKind(DEFAULT_SEARCH_KIND),
|
||||
}),
|
||||
);
|
||||
|
||||
const area = h("div", { id: "searchResults", class: "search-results", "aria-live": "polite" });
|
||||
fillSearchResults(area);
|
||||
searchHost.replaceChildren(h("div", { id: "searchPanel", class: "search-panel" }, controls, area));
|
||||
}
|
||||
|
||||
/**
|
||||
* Fill the results area from the current state. A first load with nothing yet
|
||||
* shows the spinner and `Searching…`; a refresh that retained results shows a thin
|
||||
* progress bar above them; an error takes precedence over the results; otherwise
|
||||
* the filtered and sorted rows, or the empty-state line.
|
||||
*/
|
||||
function fillSearchResults(area) {
|
||||
const shown = sortSearchResults(
|
||||
filterSearchResults(state.searchResults, state.searchKind),
|
||||
state.searchSort,
|
||||
);
|
||||
const nodes = [];
|
||||
if (searchPanelProgress(state)) {
|
||||
nodes.push(h("div", { class: "search-progress", role: "progressbar", "aria-label": "Searching" }));
|
||||
}
|
||||
const body = searchPanelBody(state, shown, state.searchKind);
|
||||
if (body.kind === "error") {
|
||||
nodes.push(h("div", { class: "search-error", text: body.message }));
|
||||
} else if (body.kind === "results") {
|
||||
for (const hit of shown) nodes.push(renderSearchResultRow(hit));
|
||||
} else if (body.kind === "searching") {
|
||||
nodes.push(
|
||||
h(
|
||||
"div",
|
||||
{ class: "search-searching muted" },
|
||||
h("span", { class: "spinner", "aria-hidden": "true" }),
|
||||
h("span", { text: "Searching…" }),
|
||||
),
|
||||
);
|
||||
} else if (body.kind === "empty") {
|
||||
nodes.push(h("div", { class: "search-empty muted", text: body.message }));
|
||||
}
|
||||
area.replaceChildren(...nodes);
|
||||
}
|
||||
|
||||
/**
|
||||
* One result row: a compact kind label (the accessibility counterpart of the
|
||||
* app's type glyph), the title and — for a text match — the server snippet with
|
||||
* the first case-insensitive query occurrence emphasised. A known payload is
|
||||
* clickable and routes to its destination; an unknown/absent payload is rendered
|
||||
* read-only and is never clickable. Every server string is set as text.
|
||||
*/
|
||||
function renderSearchResultRow(hit) {
|
||||
const row = searchRow(hit, state.searchQuery);
|
||||
const target = searchTarget(hit);
|
||||
const element = h("div", {
|
||||
class: `search-row${target ? " clickable" : " readonly"}`,
|
||||
"data-kind": String(hit?.kind ?? ""),
|
||||
});
|
||||
if (target) {
|
||||
const route = () => routeSearchResult(hit);
|
||||
element.setAttribute("role", "button");
|
||||
element.setAttribute("tabindex", "0");
|
||||
if (target.kind === "pipeline") {
|
||||
element.setAttribute("data-target", `pipeline:${target.pipelineId}:v${target.version}`);
|
||||
} else if (target.matchedField) {
|
||||
element.setAttribute("data-target", `run:${target.runId}:${target.sequence}:${target.matchedField}`);
|
||||
} else {
|
||||
element.setAttribute("data-target", `run:${target.runId}${target.sequence ? `:${target.sequence}` : ""}`);
|
||||
}
|
||||
element.addEventListener("click", route);
|
||||
element.addEventListener("keydown", (event) => {
|
||||
if (event.key === "Enter" || event.key === " ") {
|
||||
event.preventDefault();
|
||||
route();
|
||||
}
|
||||
});
|
||||
}
|
||||
element.append(h("span", { class: "search-kind muted", text: searchResultKindLabel(hit) }));
|
||||
const main = h("div", { class: "search-row-main" });
|
||||
main.append(h("div", { class: "search-row-title", text: row.title }));
|
||||
if (row.snippet != null) {
|
||||
const line = h("div", { class: "search-row-snippet muted" });
|
||||
for (const span of row.snippet) {
|
||||
if (span.matched) {
|
||||
line.append(h("strong", { class: "search-match" }, h("u", {}, span.text)));
|
||||
} else {
|
||||
line.append(document.createTextNode(span.text));
|
||||
}
|
||||
}
|
||||
main.append(line);
|
||||
} else if (row.secondary) {
|
||||
main.append(h("div", { class: "search-row-secondary muted", text: row.secondary }));
|
||||
}
|
||||
element.append(main);
|
||||
return element;
|
||||
}
|
||||
|
||||
/**
|
||||
* Route one selected result through the page's existing navigation, exactly as
|
||||
* the app does. The search is closed and cleared first, so every selection leaves
|
||||
* the panel; a known payload then opens the pipeline detail (at the result
|
||||
* version, 0 = latest), the run detail, the run-detail tab holding a text match,
|
||||
* or the recorded visit's stage pane (the artifact route is that same pane). A
|
||||
* visit that cannot be located falls back to the plain run detail. An unknown
|
||||
* result has no target and never navigates.
|
||||
*/
|
||||
async function routeSearchResult(hit) {
|
||||
const target = searchTarget(hit);
|
||||
if (!target) return;
|
||||
closeSearch();
|
||||
state.error = "";
|
||||
if (target.kind === "pipeline") {
|
||||
state.view = "pipelines";
|
||||
state.selectedRunId = null;
|
||||
await selectPipeline({ id: target.pipelineId, version: target.version });
|
||||
return;
|
||||
}
|
||||
state.view = "runs";
|
||||
await selectRun(target.runId);
|
||||
if (!state.runDetail) return;
|
||||
const resolved = resolveRunTarget(target, target.runId, state.runDetail.steps ?? []);
|
||||
if (resolved.tab) {
|
||||
state.runTab = resolved.tab;
|
||||
renderContent();
|
||||
} else if (resolved.stageKey != null) {
|
||||
openStagePane(resolved.stageKey, resolved.visitIndex);
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Actions
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -2543,16 +2969,19 @@ client.addEventListener("state", (event) => {
|
||||
|
||||
// The stage pane is a modal dialog: Escape closes it (a stacked overlay — the
|
||||
// artifact viewer or the diff viewer, when either is above — owns Escape first).
|
||||
// Registered once; it is a no-op when no pane is open.
|
||||
// Once no pane is open, Escape closes the omni-search field. Registered once;
|
||||
// every branch is a no-op when nothing relevant is open.
|
||||
document.addEventListener("keydown", (event) => {
|
||||
if (
|
||||
event.key === "Escape" &&
|
||||
state.runStagePane &&
|
||||
!document.querySelector(".artifact-viewer") &&
|
||||
!document.querySelector(".change-viewer")
|
||||
) {
|
||||
if (event.key !== "Escape") return;
|
||||
if (document.querySelector(".artifact-viewer") || document.querySelector(".change-viewer")) return;
|
||||
if (state.runStagePane) {
|
||||
event.preventDefault();
|
||||
closeStagePane();
|
||||
return;
|
||||
}
|
||||
if (state.searchOpen) {
|
||||
event.preventDefault();
|
||||
closeSearch();
|
||||
}
|
||||
});
|
||||
|
||||
|
||||
@@ -21,6 +21,11 @@ export const Protocol = Object.freeze({
|
||||
GET_RUN: "get_run",
|
||||
RUN: "run",
|
||||
|
||||
// Omni-search (internal/protocol/search.go): the command and its reply type.
|
||||
// The per-kind payloads and the kind/limit vocabulary live in src/search.js.
|
||||
SEARCH: "search",
|
||||
SEARCH_RESULTS: "search_results",
|
||||
|
||||
SUCCESS_END: "#success",
|
||||
FAILURE_END: "#failure",
|
||||
});
|
||||
|
||||
@@ -72,4 +72,25 @@ export class PipelinesRepository {
|
||||
}
|
||||
return response.run_detail;
|
||||
}
|
||||
|
||||
/**
|
||||
* Omni-search. Sends exactly `SearchRequest{query, kind, limit}` from
|
||||
* internal/protocol/search.go: `kind` is the empty string for every kind, and
|
||||
* `limit` is fixed at `0` so the server applies its own default cap
|
||||
* (`SearchDefaultLimit`, 50) and never the client's — `SearchMaxLimit` (200) is
|
||||
* therefore never approached, let alone exceeded.
|
||||
*
|
||||
* Returns `reply.search_results`, the ranked `SearchResponse`, or **null** when
|
||||
* an older server answered without that payload (its default `pong`), which the
|
||||
* caller reports as "this server does not support search" rather than dropping.
|
||||
* An explicit server error is already surfaced by `client.call` as a
|
||||
* `ProtocolError` carrying the server's own text.
|
||||
*/
|
||||
async search(query, kind = "") {
|
||||
const response = await this.#client.call({
|
||||
type: Protocol.SEARCH,
|
||||
search: { query, kind, limit: 0 },
|
||||
});
|
||||
return response.search_results ?? null;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,500 @@
|
||||
// Pure, DOM-free omni-search logic for the web client, ported from the Android
|
||||
// client so the browser says and shows exactly the same things:
|
||||
// ui/OmniSearchResults.kt searchRow, snippetSpans, SearchKindFilter,
|
||||
// SearchSort, filterSearchResults,
|
||||
// sortSearchResults, searchTarget,
|
||||
// searchFieldSection, resolveRunTarget,
|
||||
// SearchSequencer, SearchUiState,
|
||||
// searchPanelEmptyMessage
|
||||
// ui/SearchResultsPanel.kt the controls summary and the empty-state copy
|
||||
// data/protocol/Message.kt the search kind vocabulary (Protocol.SEARCH_KIND_*)
|
||||
//
|
||||
// Nothing here touches the DOM or imports the app: every function is pure so the
|
||||
// per-kind row text, the in-hand filtering/ordering, the routing target and the
|
||||
// debounce/stale-token sequencing can be unit-tested without a browser. The DOM
|
||||
// wiring lives in app.js. Every server-provided string is only ever compared or
|
||||
// rendered, never parsed as markup; the caller sets it with textContent.
|
||||
import { stageCountText, parseInstant, formatLocalTimestamp } from "./pipelines.js";
|
||||
import { artifactKind, artifactKindLabel, humanBytes } from "./artifacts.js";
|
||||
import { runTimeline } from "./runDetail.js";
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Kind + sort vocabulary (ui/OmniSearchResults.kt SearchKindFilter/SearchSort)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* The kind narrowing the search control offers, in the task's order. `value` is
|
||||
* exactly the server's `SearchRequest.kind` vocabulary
|
||||
* (internal/protocol/search.go); the empty string is every kind. There is
|
||||
* deliberately no "prompts" entry: the server has no such kind, so a filter that
|
||||
* could only ever match nothing is not offered.
|
||||
*/
|
||||
export const SEARCH_KINDS = [
|
||||
{ value: "", label: "All kinds" },
|
||||
{ value: "pipeline", label: "Pipelines" },
|
||||
{ value: "run", label: "Runs" },
|
||||
{ value: "step", label: "Steps" },
|
||||
{ value: "field", label: "Fields" },
|
||||
{ value: "artifact", label: "Artifacts" },
|
||||
{ value: "version", label: "Versions" },
|
||||
];
|
||||
|
||||
/** The default, no-narrowing kind. */
|
||||
export const DEFAULT_SEARCH_KIND = "";
|
||||
|
||||
/**
|
||||
* The orders the search sort control offers. "Relevance" keeps the server's own
|
||||
* ranking (score, then recency, then a stable kind/target tie-break); "Newest
|
||||
* first" and "Name" cannot be asked of the server — its search command takes only
|
||||
* a query, an optional kind and a limit — so they order the results already in
|
||||
* hand. Every sort is stable: two results that tie keep the server's order.
|
||||
*/
|
||||
export const SEARCH_SORTS = [
|
||||
{ value: "relevance", label: "Relevance" },
|
||||
{ value: "newest", label: "Newest first" },
|
||||
{ value: "name", label: "Name" },
|
||||
];
|
||||
|
||||
/** The default, server-order sort. */
|
||||
export const DEFAULT_SEARCH_SORT = "relevance";
|
||||
|
||||
/** The quiet period after the last keystroke before a query is sent. */
|
||||
export const SEARCH_DEBOUNCE_MS = 250;
|
||||
|
||||
/**
|
||||
* The report for a server that cannot answer `search`: an explicit rejection
|
||||
* naming an unknown/unsupported command, or an older server's reply without the
|
||||
* `search_results` payload. Wording is AppViewModel.kt verbatim.
|
||||
*/
|
||||
export const SEARCH_UNSUPPORTED =
|
||||
"This server does not support search. Update the Pipelines server, then try again.";
|
||||
|
||||
/** The label for `kind` (`""` = All kinds), tolerating a stale/unknown value. */
|
||||
export function searchKindLabel(kind) {
|
||||
return (SEARCH_KINDS.find((option) => option.value === kind) ?? SEARCH_KINDS[0]).label;
|
||||
}
|
||||
|
||||
/** The label for `sort`, tolerating a stale/unknown value. */
|
||||
export function searchSortLabel(sort) {
|
||||
return (SEARCH_SORTS.find((option) => option.value === sort) ?? SEARCH_SORTS[0]).label;
|
||||
}
|
||||
|
||||
/**
|
||||
* The one-line summary of the active filter and order the collapsed controls
|
||||
* show. The item's browser wording is exactly `{Kind} · {Sort}` — deliberately
|
||||
* without the Android panel's ` (in hand)` suffix, which is a note about which
|
||||
* orders run locally rather than a report the browser needs.
|
||||
*/
|
||||
export function searchControlsSummary(kind, sort) {
|
||||
return `${searchKindLabel(kind)} · ${searchSortLabel(sort)}`;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Row model (ui/OmniSearchResults.kt searchRow / snippetSpans)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** The non-blank text, else null — the Android `takeIf { it.isNotBlank() }`. */
|
||||
function nonBlank(value) {
|
||||
const text = String(value ?? "");
|
||||
return text.trim() === "" ? null : text;
|
||||
}
|
||||
|
||||
/** A finite number for a payload field, so a missing value never prints "undefined". */
|
||||
function num(value) {
|
||||
const number = Number(value);
|
||||
return Number.isFinite(number) ? number : 0;
|
||||
}
|
||||
|
||||
/** The non-null, non-empty fragments joined with ` · `; blanks are omitted. */
|
||||
function joinNonBlank(parts) {
|
||||
return (parts ?? []).filter((part) => part != null && String(part) !== "").join(" · ");
|
||||
}
|
||||
|
||||
/** Case-insensitive string comparison, matching String.CASE_INSENSITIVE_ORDER for ASCII. */
|
||||
function compareInsensitive(a, b) {
|
||||
const x = String(a ?? "").toUpperCase();
|
||||
const y = String(b ?? "").toUpperCase();
|
||||
if (x < y) return -1;
|
||||
if (x > y) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Splits `snippet` into runs so the first case-insensitive occurrence of `query`
|
||||
* (trimmed) is a distinct, `matched` span. When the query is blank or does not
|
||||
* appear — a bare status/date query, or a server-trimmed snippet — the whole
|
||||
* snippet is returned unmatched, so the caller never drops text. An empty
|
||||
* snippet yields no spans at all. Mirrors OmniSearchResults.snippetSpans.
|
||||
*/
|
||||
export function snippetSpans(snippet, query) {
|
||||
const text = String(snippet ?? "");
|
||||
if (text === "") return [];
|
||||
const needle = String(query ?? "").trim();
|
||||
if (needle === "") return [{ text, matched: false }];
|
||||
const index = text.toLowerCase().indexOf(needle.toLowerCase());
|
||||
if (index < 0) return [{ text, matched: false }];
|
||||
const end = index + needle.length;
|
||||
const spans = [];
|
||||
if (index > 0) spans.push({ text: text.slice(0, index), matched: false });
|
||||
spans.push({ text: text.slice(index, end), matched: true });
|
||||
if (end < text.length) spans.push({ text: text.slice(end), matched: false });
|
||||
return spans;
|
||||
}
|
||||
|
||||
/**
|
||||
* The one-line non-snippet secondary line of a step hit: its outcome, route and
|
||||
* first non-blank diagnostic line, or `step {sequence}` when all are blank.
|
||||
* Mirrors OmniSearchResults.stepSecondary.
|
||||
*/
|
||||
function stepSecondary(step) {
|
||||
const diagnostic = String(step?.diagnostic ?? "");
|
||||
const line = diagnostic.split(/\r?\n/).find((candidate) => candidate.trim() !== "");
|
||||
const target = nonBlank(step?.target);
|
||||
const joined = joinNonBlank([
|
||||
nonBlank(step?.outcome),
|
||||
target ? `→ ${target}` : null,
|
||||
line == null ? null : line.trim(),
|
||||
]);
|
||||
return joined === "" ? `step ${num(step?.sequence)}` : joined;
|
||||
}
|
||||
|
||||
/**
|
||||
* One rendered search row: its `title`, its plain `secondary` line and, only for
|
||||
* a text ("field") match, a `snippet` split into spans so the matched run is
|
||||
* distinguishable without colour (the caller wraps a matched span in an emphasis
|
||||
* element). An unknown/absent payload is never dropped: it renders its stable
|
||||
* target (or a placeholder) and a `read-only` note. Every per-kind rule mirrors
|
||||
* OmniSearchResults.searchRow, including the Android blank fallbacks.
|
||||
*/
|
||||
export function searchRow(hit, query, options = {}) {
|
||||
const { timeZone } = options;
|
||||
const pipeline = hit?.pipeline;
|
||||
const version = hit?.version;
|
||||
const run = hit?.run;
|
||||
const step = hit?.step;
|
||||
const field = hit?.field;
|
||||
const artifact = hit?.artifact;
|
||||
|
||||
if (pipeline) {
|
||||
return {
|
||||
title: nonBlank(pipeline.name) ?? `pipeline ${num(pipeline.id)}`,
|
||||
secondary: `pipeline ${num(pipeline.id)} · v${num(pipeline.version)} · ${stageCountText(pipeline.stages)}`,
|
||||
snippet: null,
|
||||
};
|
||||
}
|
||||
if (version) {
|
||||
const hash = nonBlank(version.content_hash);
|
||||
return {
|
||||
title: `pipeline ${num(version.pipeline_id)} · v${num(version.version)}`,
|
||||
secondary: joinNonBlank([
|
||||
hash ? `content ${hash}` : null,
|
||||
formatLocalTimestamp(version.created_at, { timeZone }),
|
||||
]),
|
||||
snippet: null,
|
||||
};
|
||||
}
|
||||
if (run) {
|
||||
const name = nonBlank(run.pipeline_name);
|
||||
return {
|
||||
title: `run #${num(run.id)}${name ? ` · ${name}` : ""}`,
|
||||
secondary: joinNonBlank([
|
||||
nonBlank(run.status),
|
||||
nonBlank(run.workspace),
|
||||
formatLocalTimestamp(run.created_at, { timeZone }),
|
||||
]),
|
||||
snippet: null,
|
||||
};
|
||||
}
|
||||
if (step) {
|
||||
return {
|
||||
title: `run #${num(step.run_id)} · ${nonBlank(step.stage) ?? "step"} visit ${num(step.visit)}`,
|
||||
secondary: stepSecondary(step),
|
||||
snippet: null,
|
||||
};
|
||||
}
|
||||
if (field) {
|
||||
return {
|
||||
title: `run #${num(field.run_id)} · step ${num(field.sequence)} · ${nonBlank(field.field) ?? "field"}`,
|
||||
secondary: String(field.snippet ?? ""),
|
||||
snippet: snippetSpans(field.snippet, query),
|
||||
};
|
||||
}
|
||||
if (artifact) {
|
||||
return {
|
||||
title: nonBlank(artifact.name) ?? "artifact",
|
||||
secondary: joinNonBlank([
|
||||
`run #${num(artifact.run_id)}`,
|
||||
`step ${num(artifact.sequence)}`,
|
||||
nonBlank(artifact.content_type),
|
||||
humanBytes(artifact.size_bytes),
|
||||
]),
|
||||
snippet: null,
|
||||
};
|
||||
}
|
||||
const kind = nonBlank(hit?.kind);
|
||||
return {
|
||||
title: nonBlank(hit?.target) ?? "Unrecognised result",
|
||||
secondary: kind ? `kind "${kind}" · read-only` : "read-only",
|
||||
snippet: null,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* The kind in words for a row's accessible description, so a screen reader hears
|
||||
* what the row is. An artifact is named by its own content type ("Image
|
||||
* artifact", "JSON artifact"), from the same gallery classification
|
||||
* searchResultIcon uses. Mirrors OmniSearchResults.searchResultKindLabel.
|
||||
*/
|
||||
export function searchResultKindLabel(hit) {
|
||||
if (hit?.pipeline) return "Pipeline";
|
||||
if (hit?.version) return "Pipeline version";
|
||||
if (hit?.run) return "Run";
|
||||
if (hit?.step) return "Step";
|
||||
if (hit?.field) return "Field";
|
||||
if (hit?.artifact) {
|
||||
return `${artifactKindLabel(artifactKind(hit.artifact.content_type, hit.artifact.name))} artifact`;
|
||||
}
|
||||
return "Unrecognised result";
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// In-hand narrowing and ordering (SearchResultsPanel.kt SearchResultList)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Narrows `results` to `kind`'s kind (`""` = every kind). The kind is also sent
|
||||
* to the server (`SearchRequest.kind`), so this only re-narrows the results
|
||||
* already in hand, keeping the panel honest while a narrowed request loads.
|
||||
*/
|
||||
export function filterSearchResults(results, kind) {
|
||||
const list = results ?? [];
|
||||
if (kind === "" || kind == null) return list;
|
||||
return list.filter((hit) => hit?.kind === kind);
|
||||
}
|
||||
|
||||
/**
|
||||
* Orders `results` by `sort`. "Relevance" (and any stale value) leaves the
|
||||
* server's ranking untouched; "Newest first" orders by parsed recency
|
||||
* descending, with an unparseable/missing recency last; "Name" orders by the
|
||||
* displayed title, case-insensitively. Every sort is stable, so ties keep the
|
||||
* server's order rather than swapping arbitrarily.
|
||||
*/
|
||||
export function sortSearchResults(results, sort) {
|
||||
const list = results ?? [];
|
||||
if (sort === "newest") {
|
||||
return [...list].sort((a, b) => {
|
||||
const ta = parseInstant(a?.recency);
|
||||
const tb = parseInstant(b?.recency);
|
||||
const na = ta == null ? -Infinity : ta;
|
||||
const nb = tb == null ? -Infinity : tb;
|
||||
if (na === nb) return 0;
|
||||
return na > nb ? -1 : 1;
|
||||
});
|
||||
}
|
||||
if (sort === "name") {
|
||||
return [...list]
|
||||
.map((hit) => ({ hit, title: searchRow(hit, "").title }))
|
||||
.sort((a, b) => compareInsensitive(a.title, b.title))
|
||||
.map((entry) => entry.hit);
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
/**
|
||||
* The empty-state line the panel shows when it has no rows to render for the
|
||||
* (non-blank) query under `kind`, or null when it is showing rows, progress, an
|
||||
* error or nothing at all. `shown` is the filtered and sorted list actually
|
||||
* displayed, so a filter that empties the list reports itself ("No runs match …")
|
||||
* rather than the generic line. Mirrors searchPanelEmptyMessage.
|
||||
*
|
||||
* Android's own copy is the invariant `No {kind} match "{query}".` — the same
|
||||
* sentence shape the pipeline list already carries in src/pipelines.js — and the
|
||||
* browser keeps it verbatim.
|
||||
*/
|
||||
export function searchPanelEmptyMessage(state, shown, kind) {
|
||||
if (state?.error) return null;
|
||||
if ((shown ?? []).length > 0) return null;
|
||||
if (state?.loading) return null;
|
||||
const query = String(state?.query ?? "");
|
||||
if (query.trim() === "") return null;
|
||||
if (kind === "" || kind == null) return `No matches for "${query}".`;
|
||||
return `No ${searchKindLabel(kind).toLowerCase()} match "${query}".`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether a keystroke's text is worth asking the server about. A blank or
|
||||
* whitespace-only query is cleared locally and never sent, so the server is not
|
||||
* asked to scan for nothing. The one predicate the field's input handler and its
|
||||
* immediate-send path share.
|
||||
*/
|
||||
export function searchQuerySendable(query) {
|
||||
return String(query ?? "").trim() !== "";
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether the panel draws its thin refresh bar: a newer query is loading while
|
||||
* results are still on screen, so progress is reported above them rather than
|
||||
* blanking the list. Pure, so "retained results plus progress on a refresh" is
|
||||
* testable without a browser.
|
||||
*/
|
||||
export function searchPanelProgress(state) {
|
||||
return Boolean(state?.loading) && (state?.results ?? []).length > 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* The body the panel renders, mirroring SearchResultsPanel's `when` in order: an
|
||||
* error takes precedence over the results; the filtered/sorted rows when there
|
||||
* are any; the first-load searching row while nothing has arrived; otherwise the
|
||||
* empty-state line, or nothing at all (a blank query, or a filter that emptied a
|
||||
* list while a refresh is in flight). Pure, so every state is unit-testable
|
||||
* without a browser.
|
||||
*/
|
||||
export function searchPanelBody(state, shown, kind) {
|
||||
if (state?.error) return { kind: "error", message: state.error };
|
||||
if ((shown ?? []).length > 0) return { kind: "results", message: "" };
|
||||
// The searching row is the first load only: once any result is retained, a
|
||||
// refresh reports itself with the progress bar instead of replacing the list.
|
||||
if (state?.loading && (state?.results ?? []).length === 0) return { kind: "searching", message: "" };
|
||||
const message = searchPanelEmptyMessage(state, shown, kind);
|
||||
return message == null ? { kind: "idle", message: "" } : { kind: "empty", message };
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Navigation (ui/OmniSearchResults.kt searchTarget / resolveRunTarget)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* The navigation a selected search result asks for, or null for a kind with no
|
||||
* known payload (an unknown match), which is shown read-only rather than dropped.
|
||||
* A pipeline/version target names the pipeline detail (version 0 = latest); a
|
||||
* run target names a run, and carries the recorded `sequence` (0 = the plain run
|
||||
* detail) plus, for a text match, the `matchedField` naming the run-detail tab
|
||||
* holding the match.
|
||||
*/
|
||||
export function searchTarget(hit) {
|
||||
if (hit?.pipeline) {
|
||||
return { kind: "pipeline", pipelineId: num(hit.pipeline.id), version: num(hit.pipeline.version) };
|
||||
}
|
||||
if (hit?.version) {
|
||||
return {
|
||||
kind: "pipeline",
|
||||
pipelineId: num(hit.version.pipeline_id),
|
||||
version: num(hit.version.version),
|
||||
};
|
||||
}
|
||||
if (hit?.run) return { kind: "run", runId: num(hit.run.id), sequence: 0, matchedField: "" };
|
||||
if (hit?.step) {
|
||||
return { kind: "run", runId: num(hit.step.run_id), sequence: num(hit.step.sequence), matchedField: "" };
|
||||
}
|
||||
if (hit?.field) {
|
||||
// The run-detail tab is chosen from the hit's `matched_field` (the browser
|
||||
// item's deliberate rule), not from the recorded field name.
|
||||
return {
|
||||
kind: "run",
|
||||
runId: num(hit.field.run_id),
|
||||
sequence: num(hit.field.sequence),
|
||||
matchedField: String(hit.matched_field ?? ""),
|
||||
};
|
||||
}
|
||||
if (hit?.artifact) {
|
||||
return {
|
||||
kind: "run",
|
||||
runId: num(hit.artifact.run_id),
|
||||
sequence: num(hit.artifact.sequence),
|
||||
matchedField: "",
|
||||
};
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* The run-detail tab holding a matched step field's text: `input` -> Input,
|
||||
* `output` -> Output, anything else (a retired evidence/transcript tab, or an
|
||||
* unknown field) -> Summary, so no stale hit accidentally selects Timeline.
|
||||
*/
|
||||
export function searchFieldTab(matchedField) {
|
||||
switch (String(matchedField ?? "")) {
|
||||
case "input":
|
||||
return "input";
|
||||
case "output":
|
||||
return "output";
|
||||
default:
|
||||
return "summary";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolves a run `target` against the loaded run's `steps` into the pane
|
||||
* selection showing the requested tab or visit. A text match returns the tab
|
||||
* holding it; a step/artifact target returns the zero-based visit index within
|
||||
* its stage (the server's visit number need not equal the index); a visit that
|
||||
* cannot be located — or a bare run target — returns an empty selection, so the
|
||||
* plain run detail is shown and a hit is never dropped. `runId` is the run the
|
||||
* target named (kept for parity with the Android signature).
|
||||
*/
|
||||
export function resolveRunTarget(target, runId, steps) {
|
||||
if (!target) return {};
|
||||
if (String(target.matchedField ?? "").trim() !== "") {
|
||||
return { tab: searchFieldTab(target.matchedField) };
|
||||
}
|
||||
const sequence = num(target.sequence);
|
||||
if (sequence <= 0) return {};
|
||||
const list = steps ?? [];
|
||||
const step = list.find((candidate) => num(candidate?.sequence) === sequence);
|
||||
if (!step) return {};
|
||||
const visits = runTimeline(list).visitsByStage.get(step.stage) ?? [];
|
||||
const index = visits.findIndex((candidate) => num(candidate?.sequence) === sequence);
|
||||
return { stageKey: step.stage, visitIndex: Math.max(index, 0) };
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Query sequencing: debounce + stale-reply gating
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* The pure ordering behind omni-search.
|
||||
*
|
||||
* `edit` records a keystroke and returns the pending edit to debounce; when the
|
||||
* quiet period elapses the caller passes it to `begin`, which returns the query
|
||||
* to send only if no newer keystroke arrived — so a burst of keystrokes collapses
|
||||
* into one request for the last one. Every sent request carries a monotonically
|
||||
* increasing token and `accepts` is true only for the newest recorded edit, so a
|
||||
* reply for a superseded query can never overwrite a newer one. Recording an edit
|
||||
* (a keystroke, or an empty edit when the panel closes) is enough to reject an
|
||||
* already in-flight reply; no separate cancel is needed.
|
||||
*/
|
||||
export class SearchSequencer {
|
||||
#newest = 0;
|
||||
|
||||
edit(query) {
|
||||
return { token: ++this.#newest, query };
|
||||
}
|
||||
|
||||
begin(edit) {
|
||||
if (!edit || edit.token !== this.#newest) return null;
|
||||
return { token: edit.token, query: edit.query };
|
||||
}
|
||||
|
||||
accepts(token) {
|
||||
return token === this.#newest;
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Failure copy (AppViewModel.runSearch)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* The message for a failed search: the "server cannot search" sentence for a
|
||||
* missing `search_results` payload (an older server's pong) or a rejection naming
|
||||
* an unknown/unsupported command, otherwise the server's own text unchanged.
|
||||
*/
|
||||
export function searchFailureText(error) {
|
||||
if (error == null) return SEARCH_UNSUPPORTED;
|
||||
const message = (error instanceof Error ? error.message : String(error)).trim();
|
||||
if (message === "") return SEARCH_UNSUPPORTED;
|
||||
if (/\b(unknown|unsupported|unrecognised|unrecognized)\b[\s\S]*\bcommand\b/i.test(message)) {
|
||||
return SEARCH_UNSUPPORTED;
|
||||
}
|
||||
return message;
|
||||
}
|
||||
@@ -1028,3 +1028,92 @@ code { background: var(--surface-2); padding: 1px 6px; border-radius: 6px; font-
|
||||
.diff-add { color: var(--ok); }
|
||||
.diff-remove { color: var(--bad); }
|
||||
.diff-context { color: var(--muted); }
|
||||
|
||||
/* --- Omni-search (S1/S2) ------------------------------------------------- */
|
||||
|
||||
/* The panel sits in normal flow under the top bar; the wrapper disappears
|
||||
entirely while the search is closed. */
|
||||
.search-host { background: var(--surface); border-bottom: 1px solid var(--border); }
|
||||
.search-host:empty { display: none; }
|
||||
|
||||
.search-panel { padding: 10px 16px 12px; display: grid; gap: 8px; }
|
||||
|
||||
.search-controls { display: flex; gap: 10px; align-items: center; flex-wrap: wrap; }
|
||||
.search-field { display: flex; gap: 6px; align-items: center; }
|
||||
.search-field-label { color: var(--muted); font-size: 12px; }
|
||||
.search-select {
|
||||
padding: 5px 8px;
|
||||
background: var(--surface-2);
|
||||
color: var(--text);
|
||||
border: 1px solid var(--border);
|
||||
border-radius: 8px;
|
||||
font: inherit;
|
||||
}
|
||||
.search-select:focus-visible { outline: 2px solid var(--accent); outline-offset: 1px; }
|
||||
.search-summary { flex: 1 1 160px; font-size: 12px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
|
||||
.search-clear { padding: 5px 10px; font-size: 12px; }
|
||||
|
||||
.search-input { flex: 1 1 260px; }
|
||||
.search-close { white-space: nowrap; }
|
||||
|
||||
/* A bounded, self-scrolling result surface: the panel never pushes the page
|
||||
body around however many hits come back. */
|
||||
.search-results {
|
||||
max-height: min(50vh, 420px);
|
||||
overflow-y: auto;
|
||||
border: 1px solid var(--border);
|
||||
border-radius: 10px;
|
||||
background: var(--surface-2);
|
||||
}
|
||||
|
||||
/* The refresh indicator: shown above retained results rather than replacing
|
||||
them, so a re-query never blanks the list. */
|
||||
.search-progress {
|
||||
height: 3px;
|
||||
background: var(--accent);
|
||||
border-radius: 2px;
|
||||
transform-origin: left;
|
||||
animation: search-progress 1.1s ease-in-out infinite;
|
||||
}
|
||||
@keyframes search-progress {
|
||||
0% { opacity: 0.3; transform: scaleX(0.2); }
|
||||
50% { opacity: 1; transform: scaleX(1); }
|
||||
100% { opacity: 0.3; transform: scaleX(0.2); }
|
||||
}
|
||||
@media (prefers-reduced-motion: reduce) {
|
||||
.search-progress { animation: none; }
|
||||
}
|
||||
|
||||
/* A flat list of rows, with no grouping headers, matching the app. */
|
||||
.search-row {
|
||||
display: flex;
|
||||
gap: 10px;
|
||||
align-items: baseline;
|
||||
padding: 8px 12px;
|
||||
border-bottom: 1px solid var(--border);
|
||||
}
|
||||
.search-row:last-child { border-bottom: 0; }
|
||||
.search-row.clickable { cursor: pointer; }
|
||||
.search-row.clickable:hover { background: var(--surface); }
|
||||
.search-row.clickable:focus-visible { outline: 2px solid var(--accent); outline-offset: -2px; }
|
||||
.search-row.readonly { opacity: 0.85; }
|
||||
.search-kind { flex: 0 0 auto; font-size: 11px; text-transform: uppercase; letter-spacing: 0.04em; padding-top: 2px; }
|
||||
.search-row-main { flex: 1 1 auto; min-width: 0; }
|
||||
.search-row-title { font-weight: 600; }
|
||||
.search-row-secondary, .search-row-snippet {
|
||||
font-size: 12px;
|
||||
margin-top: 2px;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
}
|
||||
.search-match { color: var(--accent); }
|
||||
|
||||
.search-searching { display: flex; gap: 8px; align-items: center; padding: 12px; }
|
||||
.search-error { padding: 12px; color: var(--bad); }
|
||||
.search-empty { padding: 12px; }
|
||||
|
||||
@media (max-width: 760px) {
|
||||
.search-input { flex-basis: 100%; }
|
||||
.search-summary { flex-basis: 100%; }
|
||||
}
|
||||
|
||||
@@ -104,3 +104,43 @@ test("validate throws when the reply has no graph", async () => {
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "validated" });
|
||||
await assert.rejects(() => repo.validate("empty"), ProtocolError);
|
||||
});
|
||||
|
||||
test("search sends exactly {type:'search',search:{query,kind:'',limit:0}} and returns search_results", async () => {
|
||||
const { repo, ws } = connected();
|
||||
const payload = { query: "release", results: [{ kind: "run" }], cap: 50, scanned_steps: 3 };
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "search_results", search_results: payload });
|
||||
|
||||
const reply = await repo.search("release");
|
||||
assert.deepEqual(lastFrame(ws), {
|
||||
type: "search",
|
||||
search: { query: "release", kind: "", limit: 0 },
|
||||
});
|
||||
assert.deepEqual(reply, payload);
|
||||
});
|
||||
|
||||
test("search sends the selected kind verbatim and never a limit above the cap", async () => {
|
||||
const { repo, ws } = connected();
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "search_results", search_results: { results: [] } });
|
||||
|
||||
await repo.search("release", "run");
|
||||
const { search } = lastFrame(ws);
|
||||
assert.deepEqual(search, { query: "release", kind: "run", limit: 0 });
|
||||
// limit 0 asks for the server's own default (SearchDefaultLimit 50); the client
|
||||
// never asks for more than SearchMaxLimit (200), let alone sends a larger value.
|
||||
assert.ok(search.limit <= 200);
|
||||
});
|
||||
|
||||
test("search returns null when an older server replies without search_results", async () => {
|
||||
const { repo, ws } = connected();
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "pong" });
|
||||
assert.equal(await repo.search("release"), null);
|
||||
});
|
||||
|
||||
test("search surfaces an explicit server error with the server's own text", async () => {
|
||||
const { repo, ws } = connected();
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "error", error: "unknown command: search" });
|
||||
await assert.rejects(() => repo.search("release"), {
|
||||
name: "ProtocolError",
|
||||
message: "unknown command: search",
|
||||
});
|
||||
});
|
||||
|
||||
@@ -0,0 +1,519 @@
|
||||
// Pure omni-search tests: the per-kind row text, the in-hand narrowing and
|
||||
// ordering, the routing target/tab resolution, the debounce/stale-token sequencer
|
||||
// and the failure copy. Everything here is DOM-free and needs no server, mirroring
|
||||
// android/.../ui/OmniSearchResultsTest.kt and OmniSearchTest.kt.
|
||||
import { test } from "node:test";
|
||||
import assert from "node:assert/strict";
|
||||
|
||||
import {
|
||||
DEFAULT_SEARCH_KIND,
|
||||
DEFAULT_SEARCH_SORT,
|
||||
SEARCH_KINDS,
|
||||
SEARCH_SORTS,
|
||||
SEARCH_UNSUPPORTED,
|
||||
SearchSequencer,
|
||||
filterSearchResults,
|
||||
resolveRunTarget,
|
||||
searchControlsSummary,
|
||||
searchFailureText,
|
||||
searchFieldTab,
|
||||
searchKindLabel,
|
||||
searchPanelBody,
|
||||
searchPanelEmptyMessage,
|
||||
searchPanelProgress,
|
||||
searchQuerySendable,
|
||||
searchResultKindLabel,
|
||||
searchRow,
|
||||
searchTarget,
|
||||
snippetSpans,
|
||||
sortSearchResults,
|
||||
} from "../src/search.js";
|
||||
|
||||
const UTC = { timeZone: "UTC" };
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Fixtures — the same shapes the Android test uses
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function pipelineHit(overrides = {}) {
|
||||
return {
|
||||
kind: "pipeline",
|
||||
target: "pipeline:7",
|
||||
pipeline: { id: 7, name: "release", version: 3, stages: 4, ...overrides },
|
||||
};
|
||||
}
|
||||
|
||||
function versionHit(overrides = {}) {
|
||||
return {
|
||||
kind: "version",
|
||||
target: "pipeline:9:v2",
|
||||
version: {
|
||||
pipeline_id: 9,
|
||||
version: 2,
|
||||
content_hash: "abc",
|
||||
created_at: "2026-01-01T00:00:00Z",
|
||||
...overrides,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function runHit(overrides = {}) {
|
||||
return {
|
||||
kind: "run",
|
||||
target: "run:11",
|
||||
run: {
|
||||
id: 11,
|
||||
pipeline_name: "release",
|
||||
status: "succeeded",
|
||||
created_at: "2026-01-01T00:00:00Z",
|
||||
...overrides,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function stepHit(overrides = {}) {
|
||||
return {
|
||||
kind: "step",
|
||||
target: "run:11:4",
|
||||
step: { run_id: 11, sequence: 4, stage: "builder", visit: 2, outcome: "success", ...overrides },
|
||||
};
|
||||
}
|
||||
|
||||
function fieldHit(overrides = {}, matchedField = "output") {
|
||||
return {
|
||||
kind: "field",
|
||||
target: "run:11:4:output",
|
||||
matched_field: matchedField,
|
||||
field: {
|
||||
run_id: 11,
|
||||
sequence: 4,
|
||||
field: "output",
|
||||
snippet: "the release is ready",
|
||||
...overrides,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function artifactHit(overrides = {}) {
|
||||
return {
|
||||
kind: "artifact",
|
||||
target: "/artifacts/11/4/notes.md",
|
||||
artifact: {
|
||||
run_id: 11,
|
||||
sequence: 4,
|
||||
name: "notes.md",
|
||||
content_type: "text/markdown",
|
||||
size_bytes: 2048,
|
||||
url: "/artifacts/11/4/notes.md",
|
||||
...overrides,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Kind/sort vocabulary
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("the kind options are exactly the server vocabulary, All kinds first", () => {
|
||||
assert.deepEqual(
|
||||
SEARCH_KINDS.map((option) => [option.value, option.label]),
|
||||
[
|
||||
["", "All kinds"],
|
||||
["pipeline", "Pipelines"],
|
||||
["run", "Runs"],
|
||||
["step", "Steps"],
|
||||
["field", "Fields"],
|
||||
["artifact", "Artifacts"],
|
||||
["version", "Versions"],
|
||||
],
|
||||
);
|
||||
assert.equal(DEFAULT_SEARCH_KIND, "");
|
||||
assert.deepEqual(
|
||||
SEARCH_SORTS.map((option) => [option.value, option.label]),
|
||||
[
|
||||
["relevance", "Relevance"],
|
||||
["newest", "Newest first"],
|
||||
["name", "Name"],
|
||||
],
|
||||
);
|
||||
assert.equal(DEFAULT_SEARCH_SORT, "relevance");
|
||||
// A stale/unknown value falls back rather than inventing an option.
|
||||
assert.equal(searchKindLabel("prompts"), "All kinds");
|
||||
assert.equal(searchKindLabel("run"), "Runs");
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Row text
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("pipeline rows carry the name (or the id fallback) and the version/stage line", () => {
|
||||
assert.deepEqual(searchRow(pipelineHit(), "release", UTC), {
|
||||
title: "release",
|
||||
secondary: "pipeline 7 · v3 · 4 stages",
|
||||
snippet: null,
|
||||
});
|
||||
const blank = searchRow(pipelineHit({ name: " " }), "release", UTC);
|
||||
assert.equal(blank.title, "pipeline 7");
|
||||
// The stage count keeps the app's singular form.
|
||||
assert.equal(searchRow(pipelineHit({ stages: 1 }), "", UTC).secondary, "pipeline 7 · v3 · 1 stage");
|
||||
});
|
||||
|
||||
test("version rows name the pipeline/version and omit blank content parts", () => {
|
||||
assert.deepEqual(searchRow(versionHit(), "release", UTC), {
|
||||
title: "pipeline 9 · v2",
|
||||
secondary: "content abc · 1 Jan 00:00",
|
||||
snippet: null,
|
||||
});
|
||||
const blankHash = searchRow(versionHit({ content_hash: " " }), "release", UTC);
|
||||
assert.equal(blankHash.secondary, "1 Jan 00:00");
|
||||
});
|
||||
|
||||
test("run rows join the non-blank status, workspace and timestamp", () => {
|
||||
assert.deepEqual(searchRow(runHit(), "release", UTC), {
|
||||
title: "run #11 · release",
|
||||
secondary: "succeeded · 1 Jan 00:00",
|
||||
snippet: null,
|
||||
});
|
||||
const withWorkspace = searchRow(runHit({ workspace: "/tmp/ws" }), "", UTC);
|
||||
assert.equal(withWorkspace.secondary, "succeeded · /tmp/ws · 1 Jan 00:00");
|
||||
const unnamed = searchRow(runHit({ pipeline_name: "" }), "", UTC);
|
||||
assert.equal(unnamed.title, "run #11");
|
||||
});
|
||||
|
||||
test("step rows carry outcome, route and the first non-blank diagnostic line", () => {
|
||||
const withTarget = searchRow(stepHit({ target: "#success" }), "", UTC);
|
||||
assert.deepEqual(withTarget, {
|
||||
title: "run #11 · builder visit 2",
|
||||
secondary: "success · → #success",
|
||||
snippet: null,
|
||||
});
|
||||
const withDiagnostic = searchRow(
|
||||
stepHit({ diagnostic: "\n the first line\nsecond line" }),
|
||||
"",
|
||||
UTC,
|
||||
);
|
||||
assert.equal(withDiagnostic.secondary, "success · the first line");
|
||||
// Every part blank: the sequence is the honest fallback.
|
||||
const allBlank = searchRow(stepHit({ outcome: "", target: "", diagnostic: "" }), "", UTC);
|
||||
assert.equal(allBlank.secondary, "step 4");
|
||||
// A blank stage falls back to the word "step".
|
||||
assert.equal(searchRow(stepHit({ stage: "" }), "", UTC).title, "run #11 · step visit 2");
|
||||
});
|
||||
|
||||
test("field rows carry the server snippet with the matched query span", () => {
|
||||
const row = searchRow(fieldHit(), "release", UTC);
|
||||
assert.equal(row.title, "run #11 · step 4 · output");
|
||||
assert.equal(row.secondary, "the release is ready");
|
||||
assert.deepEqual(row.snippet, [
|
||||
{ text: "the ", matched: false },
|
||||
{ text: "release", matched: true },
|
||||
{ text: " is ready", matched: false },
|
||||
]);
|
||||
// No occurrence: one unmatched run, never dropped text.
|
||||
assert.deepEqual(searchRow(fieldHit(), "absent", UTC).snippet, [
|
||||
{ text: "the release is ready", matched: false },
|
||||
]);
|
||||
// A blank field falls back to the word "field".
|
||||
assert.equal(searchRow(fieldHit({ field: " " }), "release", UTC).title, "run #11 · step 4 · field");
|
||||
});
|
||||
|
||||
test("artifact rows join name, run, step, content type and human size", () => {
|
||||
assert.deepEqual(searchRow(artifactHit(), "notes", UTC), {
|
||||
title: "notes.md",
|
||||
secondary: "run #11 · step 4 · text/markdown · 2.0 KiB",
|
||||
snippet: null,
|
||||
});
|
||||
assert.equal(searchRow(artifactHit({ name: "", content_type: "" }), "", UTC).title, "artifact");
|
||||
});
|
||||
|
||||
test("an unknown row is read-only and never dropped", () => {
|
||||
const named = searchRow({ kind: "future_kind", target: "widget:7" }, "x", UTC);
|
||||
assert.deepEqual(named, {
|
||||
title: "widget:7",
|
||||
secondary: 'kind "future_kind" · read-only',
|
||||
snippet: null,
|
||||
});
|
||||
const anonymous = searchRow({ kind: "", target: "" }, "x", UTC);
|
||||
assert.deepEqual(anonymous, { title: "Unrecognised result", secondary: "read-only", snippet: null });
|
||||
});
|
||||
|
||||
test("snippetSpans splits only the first occurrence, case-insensitively", () => {
|
||||
assert.deepEqual(snippetSpans("the Release notes mention it", "release"), [
|
||||
{ text: "the ", matched: false },
|
||||
{ text: "Release", matched: true },
|
||||
{ text: " notes mention it", matched: false },
|
||||
]);
|
||||
// The FIRST occurrence is the emphasised one; a later one is left in the tail.
|
||||
assert.deepEqual(snippetSpans("aXbXc", "x"), [
|
||||
{ text: "a", matched: false },
|
||||
{ text: "X", matched: true },
|
||||
{ text: "bXc", matched: false },
|
||||
]);
|
||||
// A match at the very start/end needs no empty leading/trailing run.
|
||||
assert.deepEqual(snippetSpans("release", "release"), [{ text: "release", matched: true }]);
|
||||
assert.deepEqual(snippetSpans("nothing here", "release"), [{ text: "nothing here", matched: false }]);
|
||||
assert.deepEqual(snippetSpans("nothing here", " "), [{ text: "nothing here", matched: false }]);
|
||||
assert.deepEqual(snippetSpans("", "release"), []);
|
||||
});
|
||||
|
||||
test("searchResultKindLabel names the kind in words, artifact by its content type", () => {
|
||||
assert.equal(searchResultKindLabel(pipelineHit()), "Pipeline");
|
||||
assert.equal(searchResultKindLabel(versionHit()), "Pipeline version");
|
||||
assert.equal(searchResultKindLabel(runHit()), "Run");
|
||||
assert.equal(searchResultKindLabel(stepHit()), "Step");
|
||||
assert.equal(searchResultKindLabel(fieldHit()), "Field");
|
||||
assert.equal(searchResultKindLabel(artifactHit({ content_type: "text/markdown" })), "Document artifact");
|
||||
assert.equal(
|
||||
searchResultKindLabel(artifactHit({ name: "shot.png", content_type: "image/png" })),
|
||||
"Image artifact",
|
||||
);
|
||||
assert.equal(searchResultKindLabel({ kind: "future_kind", target: "x" }), "Unrecognised result");
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Kind filtering + in-hand sorting
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("the kind filter narrows the list, and All kinds keeps it whole", () => {
|
||||
const mixed = [pipelineHit(), runHit(), stepHit(), fieldHit(), artifactHit(), versionHit()];
|
||||
assert.deepEqual(filterSearchResults(mixed, ""), mixed);
|
||||
assert.deepEqual(filterSearchResults(mixed, "run"), [mixed[1]]);
|
||||
assert.deepEqual(filterSearchResults(mixed, "version"), [mixed[5]]);
|
||||
assert.deepEqual(filterSearchResults(mixed, "nothing"), []);
|
||||
});
|
||||
|
||||
function hitWithRecency(kind, recency) {
|
||||
return { kind, target: `${kind}:1`, recency };
|
||||
}
|
||||
|
||||
test("Relevance keeps the server's ranking untouched", () => {
|
||||
const ordered = [
|
||||
hitWithRecency("run", "2026-01-01T00:00:00Z"),
|
||||
hitWithRecency("pipeline", "2026-03-01T00:00:00Z"),
|
||||
];
|
||||
assert.deepEqual(sortSearchResults(ordered, "relevance"), ordered);
|
||||
assert.deepEqual(sortSearchResults(ordered, "stale-sort-value"), ordered);
|
||||
});
|
||||
|
||||
test("Newest first orders by parsed recency, descending", () => {
|
||||
const older = hitWithRecency("run", "2026-01-01T00:00:00Z");
|
||||
const newer = hitWithRecency("pipeline", "2026-03-01T00:00:00Z");
|
||||
assert.deepEqual(sortSearchResults([older, newer], "newest"), [newer, older]);
|
||||
});
|
||||
|
||||
test("Newest first keeps ties stable, and puts a missing/invalid recency last", () => {
|
||||
const first = hitWithRecency("run", "2026-01-01T00:00:00Z");
|
||||
const second = hitWithRecency("pipeline", "2026-01-01T00:00:00Z");
|
||||
assert.deepEqual(sortSearchResults([first, second], "newest"), [first, second]);
|
||||
|
||||
const dated = hitWithRecency("run", "2026-01-01T00:00:00Z");
|
||||
const undated = hitWithRecency("run", null);
|
||||
const invalid = hitWithRecency("run", "not-a-date");
|
||||
assert.deepEqual(sortSearchResults([undated, invalid, dated], "newest"), [dated, undated, invalid]);
|
||||
});
|
||||
|
||||
test("Name orders by the displayed title, case-insensitively, with ties stable", () => {
|
||||
const alpha1 = pipelineHit({ id: 1, name: "alpha" });
|
||||
const beta = pipelineHit({ id: 2, name: "Beta" });
|
||||
const alpha2 = pipelineHit({ id: 3, name: "ALPHA" });
|
||||
assert.deepEqual(sortSearchResults([beta, alpha1, alpha2], "name"), [alpha1, alpha2, beta]);
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Summary + empty state
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("the controls summary is exactly {Kind} · {Sort}, with no (in hand) suffix", () => {
|
||||
assert.equal(searchControlsSummary("", "relevance"), "All kinds · Relevance");
|
||||
assert.equal(searchControlsSummary("run", "newest"), "Runs · Newest first");
|
||||
assert.equal(searchControlsSummary("field", "name"), "Fields · Name");
|
||||
assert.equal(searchControlsSummary("bogus", "bogus"), "All kinds · Relevance");
|
||||
});
|
||||
|
||||
test("the empty state names the query and the active filter, or nothing", () => {
|
||||
const empty = { query: "release", loading: false, error: "" };
|
||||
assert.equal(searchPanelEmptyMessage(empty, [], ""), 'No matches for "release".');
|
||||
assert.equal(searchPanelEmptyMessage(empty, [], "run"), 'No runs match "release".');
|
||||
assert.equal(searchPanelEmptyMessage(empty, [], "version"), 'No versions match "release".');
|
||||
// Rows shown, still loading, a blank query or an error: no message at all.
|
||||
assert.equal(searchPanelEmptyMessage(empty, [runHit()], ""), null);
|
||||
assert.equal(searchPanelEmptyMessage({ ...empty, loading: true }, [], ""), null);
|
||||
assert.equal(searchPanelEmptyMessage({ query: " " }, [], ""), null);
|
||||
assert.equal(searchPanelEmptyMessage({ ...empty, error: "boom" }, [], ""), null);
|
||||
});
|
||||
|
||||
test("a blank or whitespace query is never sent to the server", () => {
|
||||
assert.equal(searchQuerySendable(""), false);
|
||||
assert.equal(searchQuerySendable(" "), false);
|
||||
assert.equal(searchQuerySendable(undefined), false);
|
||||
assert.equal(searchQuerySendable("plan"), true);
|
||||
assert.equal(searchQuerySendable(" plan "), true);
|
||||
});
|
||||
|
||||
test("the refresh bar shows only when results are retained while a newer query loads", () => {
|
||||
assert.equal(searchPanelProgress({ loading: true, results: [runHit()] }), true);
|
||||
assert.equal(searchPanelProgress({ loading: true, results: [] }), false);
|
||||
assert.equal(searchPanelProgress({ loading: false, results: [runHit()] }), false);
|
||||
assert.equal(searchPanelProgress({}), false);
|
||||
});
|
||||
|
||||
test("the panel body reports an error first, then rows, Searching…, the empty line or nothing", () => {
|
||||
const loading = { query: "plan", loading: true, results: [], error: "" };
|
||||
// The first load, nothing yet: the searching row.
|
||||
assert.deepEqual(searchPanelBody(loading, [], ""), { kind: "searching", message: "" });
|
||||
// A retained result set is still shown while a refresh is in flight.
|
||||
const refresh = { query: "plan", loading: true, results: [runHit()], error: "" };
|
||||
assert.deepEqual(searchPanelBody(refresh, [runHit()], ""), { kind: "results", message: "" });
|
||||
// An error takes precedence over results.
|
||||
assert.deepEqual(searchPanelBody({ ...refresh, error: "boom" }, [runHit()], ""), {
|
||||
kind: "error",
|
||||
message: "boom",
|
||||
});
|
||||
// A landed, empty reply: the empty-state sentence, naming the kind when set.
|
||||
const landed = { query: "plan", loading: false, results: [], error: "" };
|
||||
assert.deepEqual(searchPanelBody(landed, [], ""), { kind: "empty", message: 'No matches for "plan".' });
|
||||
assert.deepEqual(searchPanelBody(landed, [], "run"), {
|
||||
kind: "empty",
|
||||
message: 'No runs match "plan".',
|
||||
});
|
||||
// A blank query, or a filter that emptied a list while a refresh is in flight:
|
||||
// nothing at all.
|
||||
assert.deepEqual(searchPanelBody({ query: " ", loading: false }, [], ""), { kind: "idle", message: "" });
|
||||
assert.deepEqual(searchPanelBody(refresh, [], "run"), { kind: "idle", message: "" });
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Routing target + tab resolution
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("pipeline and version hits open the pipeline detail (version 0 = latest)", () => {
|
||||
assert.deepEqual(searchTarget(pipelineHit()), { kind: "pipeline", pipelineId: 7, version: 3 });
|
||||
assert.deepEqual(searchTarget(pipelineHit({ version: 0 })), {
|
||||
kind: "pipeline",
|
||||
pipelineId: 7,
|
||||
version: 0,
|
||||
});
|
||||
assert.deepEqual(searchTarget(versionHit()), { kind: "pipeline", pipelineId: 9, version: 2 });
|
||||
});
|
||||
|
||||
test("run, step, field and artifact hits open runs", () => {
|
||||
assert.deepEqual(searchTarget(runHit()), { kind: "run", runId: 11, sequence: 0, matchedField: "" });
|
||||
assert.deepEqual(searchTarget(stepHit()), { kind: "run", runId: 11, sequence: 4, matchedField: "" });
|
||||
assert.deepEqual(searchTarget(fieldHit({}, "output")), {
|
||||
kind: "run",
|
||||
runId: 11,
|
||||
sequence: 4,
|
||||
matchedField: "output",
|
||||
});
|
||||
assert.deepEqual(searchTarget(artifactHit()), { kind: "run", runId: 11, sequence: 4, matchedField: "" });
|
||||
});
|
||||
|
||||
test("an unknown result has no target and is never navigated", () => {
|
||||
assert.equal(searchTarget({ kind: "future_kind", target: "widget:7" }), null);
|
||||
});
|
||||
|
||||
test("the matched field resolves the run-detail tab, everything else Summary", () => {
|
||||
assert.equal(searchFieldTab("input"), "input");
|
||||
assert.equal(searchFieldTab("output"), "output");
|
||||
assert.equal(searchFieldTab("transcript"), "summary");
|
||||
assert.equal(searchFieldTab("evidence"), "summary");
|
||||
assert.equal(searchFieldTab("other"), "summary");
|
||||
assert.equal(searchFieldTab(""), "summary");
|
||||
assert.equal(searchFieldTab(undefined), "summary");
|
||||
});
|
||||
|
||||
const STEPS = [
|
||||
{ sequence: 1, stage: "planner" },
|
||||
{ sequence: 2, stage: "builder" },
|
||||
{ sequence: 3, stage: "builder" },
|
||||
];
|
||||
|
||||
test("a text-match target resolves to the run-detail tab holding it", () => {
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, matchedField: "input" }, 11, STEPS), {
|
||||
tab: "input",
|
||||
});
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, matchedField: "output" }, 11, STEPS), {
|
||||
tab: "output",
|
||||
});
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, matchedField: "transcript" }, 11, STEPS), {
|
||||
tab: "summary",
|
||||
});
|
||||
});
|
||||
|
||||
test("a step/artifact target resolves the visit index within its stage, not the visit number", () => {
|
||||
// "builder" recorded two visits; sequence 3 is its second, index 1.
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, sequence: 3 }, 11, STEPS), {
|
||||
stageKey: "builder",
|
||||
visitIndex: 1,
|
||||
});
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, sequence: 2 }, 11, STEPS), {
|
||||
stageKey: "builder",
|
||||
visitIndex: 0,
|
||||
});
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, sequence: 1 }, 11, STEPS), {
|
||||
stageKey: "planner",
|
||||
visitIndex: 0,
|
||||
});
|
||||
});
|
||||
|
||||
test("a bare run target or a visit that cannot be located falls back to the run detail", () => {
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, sequence: 0 }, 11, STEPS), {});
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, sequence: 99 }, 11, STEPS), {});
|
||||
assert.deepEqual(resolveRunTarget(null, 11, STEPS), {});
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, sequence: 1 }, 11, []), {});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Debounce + stale-reply sequencing
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("a burst of keystrokes collapses to one request for the last query", () => {
|
||||
const sequencer = new SearchSequencer();
|
||||
const first = sequencer.edit("r");
|
||||
const second = sequencer.edit("re");
|
||||
const third = sequencer.edit("rel");
|
||||
assert.equal(sequencer.begin(first), null);
|
||||
assert.equal(sequencer.begin(second), null);
|
||||
assert.deepEqual(sequencer.begin(third), { token: third.token, query: "rel" });
|
||||
});
|
||||
|
||||
test("only the newest recorded edit is accepted, so a stale reply can never land", () => {
|
||||
const sequencer = new SearchSequencer();
|
||||
const sentOld = sequencer.begin(sequencer.edit("old"));
|
||||
// A keystroke while the old reply is in flight invalidates it immediately.
|
||||
const next = sequencer.edit("new");
|
||||
assert.equal(sequencer.accepts(sentOld.token), false);
|
||||
const sentNew = sequencer.begin(next);
|
||||
assert.equal(sequencer.accepts(sentNew.token), true);
|
||||
// A token that was never recorded is not accepted either.
|
||||
assert.equal(sequencer.accepts(sentNew.token + 100), false);
|
||||
// Closing records an empty edit, which invalidates the in-flight reply too.
|
||||
sequencer.edit("");
|
||||
assert.equal(sequencer.accepts(sentNew.token), false);
|
||||
});
|
||||
|
||||
test("Enter sends the current query at once, skipping the debounce", () => {
|
||||
const sequencer = new SearchSequencer();
|
||||
sequencer.edit("release");
|
||||
const sent = sequencer.begin(sequencer.edit("release"));
|
||||
assert.deepEqual(sent, { token: sent.token, query: "release" });
|
||||
assert.equal(sequencer.accepts(sent.token), true);
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Failure copy
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("a missing payload or an unknown command reports the unsupported sentence", () => {
|
||||
assert.equal(searchFailureText(null), SEARCH_UNSUPPORTED);
|
||||
assert.equal(searchFailureText(undefined), SEARCH_UNSUPPORTED);
|
||||
assert.equal(searchFailureText(new Error("")), SEARCH_UNSUPPORTED);
|
||||
assert.equal(searchFailureText(new Error("unknown command: search")), SEARCH_UNSUPPORTED);
|
||||
assert.equal(searchFailureText(new Error("unsupported command")), SEARCH_UNSUPPORTED);
|
||||
});
|
||||
|
||||
test("any other failure carries the server's own text", () => {
|
||||
assert.equal(searchFailureText(new Error("boom")), "boom");
|
||||
assert.equal(searchFailureText(new Error("request timed out after 30000ms")), "request timed out after 30000ms");
|
||||
assert.equal(searchFailureText("plain string"), "plain string");
|
||||
});
|
||||
@@ -98,6 +98,74 @@ async function openRunDetail(runId) {
|
||||
}
|
||||
}
|
||||
|
||||
// --- Omni-search (S1/S2) ---------------------------------------------------
|
||||
// The page's own search UI drives every one of the helpers below; nothing is
|
||||
// stubbed. `searchTargets` opens the panel (if it is not already open), types the
|
||||
// query, applies the kind filter and returns the `data-target` of every row of
|
||||
// that kind once one has rendered.
|
||||
|
||||
async function searchTargets(query, kind) {
|
||||
await ensureConnected();
|
||||
if (!(await page.evaluate(`!!document.querySelector("#searchInput")`))) {
|
||||
await page.click("#searchToggle");
|
||||
await page.waitForSelector("#searchInput", { timeout: 15000 });
|
||||
}
|
||||
await page.fill("#searchInput", query);
|
||||
await page.evaluate(`(() => {
|
||||
const select = document.querySelector("#searchKind");
|
||||
select.value = ${JSON.stringify(kind)};
|
||||
select.dispatchEvent(new Event("change", { bubbles: true }));
|
||||
})()`);
|
||||
await eventually(
|
||||
() =>
|
||||
page.evaluate(
|
||||
`[...document.querySelectorAll("#searchResults .search-row")].some((r) => r.dataset.kind === ${JSON.stringify(kind)})`,
|
||||
),
|
||||
{ timeout: 25000, what: `a ${kind} search result` },
|
||||
);
|
||||
return page.evaluate(
|
||||
`[...document.querySelectorAll("#searchResults .search-row")]
|
||||
.filter((r) => r.dataset.kind === ${JSON.stringify(kind)})
|
||||
.map((r) => r.dataset.target ?? "")`,
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Click one search row by its exact data-target; routing closes the panel. The
|
||||
* lookup and the click happen in one evaluate so a reply landing between them
|
||||
* cannot replace the row first. This drives the row's own click handler, exactly
|
||||
* as a mouse click would.
|
||||
*/
|
||||
async function clickSearchTarget(target) {
|
||||
return page.evaluate(`(() => {
|
||||
const row = [...document.querySelectorAll("#searchResults .search-row")]
|
||||
.find((r) => (r.dataset.target ?? "") === ${JSON.stringify(target)});
|
||||
if (!row) return false;
|
||||
row.click();
|
||||
return true;
|
||||
})()`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Route candidate rows of `kind` until the expected destination renders (routing
|
||||
* always closes the panel, so each attempt reopens and re-queries). Live data can
|
||||
* change between runs, so up to `attempts` rows are tried before giving up;
|
||||
* returns the target that landed or null.
|
||||
*/
|
||||
async function routeSearchKind(query, kind, landed, attempts = 4) {
|
||||
const targets = await searchTargets(query, kind);
|
||||
for (const target of targets.slice(0, attempts)) {
|
||||
await searchTargets(query, kind);
|
||||
if (!(await clickSearchTarget(target))) continue;
|
||||
if (await landed()) return target;
|
||||
await page.evaluate(`document.querySelector(".stage-pane-back")?.click()`);
|
||||
await eventually(() => page.evaluate(`!document.querySelector(".stage-pane")`), {
|
||||
timeout: 5000,
|
||||
}).catch(() => {});
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
// The mounted graph's current transform, read back so the pan/zoom clamp checks
|
||||
// assert the real rendered state rather than a claim.
|
||||
const graphState = () =>
|
||||
@@ -1325,6 +1393,322 @@ try {
|
||||
shots.push(await page.screenshot(`${out}/34-run-${pendingRunId}-changes-pending.png`));
|
||||
}
|
||||
|
||||
// S1/S2: omni-search over the real server. The panel is opened from the top
|
||||
// bar; the query is typed through the page's own field, the flat result list
|
||||
// and its controls are asserted, a kind filter is applied and captured, and one
|
||||
// result of each kind is routed to its real destination. Every capture below is
|
||||
// a real screenshot of the rendered page.
|
||||
step("opening omni-search from the top bar (S1)");
|
||||
await ensureConnected();
|
||||
await page.clickText("nav.tabs button.tab", "Runs");
|
||||
await page.waitForSelector(".list.runs .run-row", { timeout: 25000 });
|
||||
const viewSnapshot = () =>
|
||||
page.evaluate(`(() => ({
|
||||
tab: document.querySelector("nav.tabs button.tab.active")?.textContent ?? "",
|
||||
detail: document.querySelector("#content .detail h2")?.textContent ?? "",
|
||||
}))()`);
|
||||
const beforeOpen = await viewSnapshot();
|
||||
await page.click("#searchToggle");
|
||||
await page.waitForSelector("#searchInput", { timeout: 15000 });
|
||||
const chrome = await page.evaluate(`(() => {
|
||||
const input = document.querySelector("#searchInput");
|
||||
return {
|
||||
placeholder: input?.getAttribute("placeholder") ?? "",
|
||||
autofocused: document.activeElement === input,
|
||||
close: document.querySelector("#searchClose")?.textContent ?? "",
|
||||
};
|
||||
})()`);
|
||||
if (chrome.placeholder !== "Search pipelines, runs and artifacts") {
|
||||
throw new Error(`search placeholder is wrong: ${chrome.placeholder}`);
|
||||
}
|
||||
if (!chrome.autofocused) throw new Error("the search field was not autofocused on open");
|
||||
if (chrome.close !== "Close search") throw new Error(`the close control is wrong: ${chrome.close}`);
|
||||
const afterOpen = await viewSnapshot();
|
||||
if (afterOpen.tab !== beforeOpen.tab || afterOpen.detail !== beforeOpen.detail) {
|
||||
throw new Error(`opening search changed the view: ${JSON.stringify({ beforeOpen, afterOpen })}`);
|
||||
}
|
||||
console.log(
|
||||
` field autofocused, placeholder "${chrome.placeholder}", "${chrome.close}" present; view stayed ${afterOpen.tab}`,
|
||||
);
|
||||
|
||||
const SEARCH_QUERY = "plan";
|
||||
step(`running a real query ("${SEARCH_QUERY}") and capturing the flat result list (S1)`);
|
||||
await page.fill("#searchInput", SEARCH_QUERY);
|
||||
await page.waitForSelector("#searchResults .search-row", { timeout: 25000 });
|
||||
const list = await page.evaluate(`(() => ({
|
||||
kinds: [...document.querySelectorAll("#searchKind option")].map((o) => o.textContent),
|
||||
sorts: [...document.querySelectorAll("#searchSort option")].map((o) => o.textContent),
|
||||
kindValue: document.querySelector("#searchKind")?.value ?? "",
|
||||
sortValue: document.querySelector("#searchSort")?.value ?? "",
|
||||
summary: document.querySelector("#searchSummary")?.textContent ?? "",
|
||||
clear: document.querySelector("#searchClearFilter")?.textContent ?? "",
|
||||
rows: document.querySelectorAll("#searchResults .search-row").length,
|
||||
headers: document.querySelectorAll("#searchResults h1, #searchResults h2, #searchResults h3").length,
|
||||
kindsPresent: [...new Set([...document.querySelectorAll("#searchResults .search-row")].map((r) => r.dataset.kind))],
|
||||
matchedSpans: document.querySelectorAll("#searchResults .search-match").length,
|
||||
}))()`);
|
||||
if (
|
||||
JSON.stringify(list.kinds) !==
|
||||
JSON.stringify(["All kinds", "Pipelines", "Runs", "Steps", "Fields", "Artifacts", "Versions"])
|
||||
) {
|
||||
throw new Error(`kind options are wrong: ${list.kinds.join(",")}`);
|
||||
}
|
||||
if (JSON.stringify(list.sorts) !== JSON.stringify(["Relevance", "Newest first", "Name"])) {
|
||||
throw new Error(`sort options are wrong: ${list.sorts.join(",")}`);
|
||||
}
|
||||
if (list.kindValue !== "" || list.sortValue !== "relevance") {
|
||||
throw new Error(`the default controls are wrong: kind=${list.kindValue} sort=${list.sortValue}`);
|
||||
}
|
||||
if (list.summary !== "All kinds · Relevance") throw new Error(`the summary line is wrong: ${list.summary}`);
|
||||
if (list.clear !== "Clear filter") throw new Error(`the reset control is wrong: ${list.clear}`);
|
||||
if (!list.rows) throw new Error("the query rendered no result rows");
|
||||
if (list.headers !== 0) throw new Error("the result list carries grouping headers, not a flat list");
|
||||
if (list.kindsPresent.length < 2) {
|
||||
throw new Error(`the query returned only ${list.kindsPresent.join(",")}, expected a mixed list`);
|
||||
}
|
||||
console.log(
|
||||
` ${list.rows} flat rows across ${list.kindsPresent.join(",")}; summary "${list.summary}"; ` +
|
||||
`${list.matchedSpans} emphasised snippet span(s)`,
|
||||
);
|
||||
await page.rect("#searchPanel");
|
||||
await shot("01-search-results.png");
|
||||
|
||||
step("applying a kind filter and capturing it (S1)");
|
||||
await page.evaluate(`(() => {
|
||||
const select = document.querySelector("#searchKind");
|
||||
select.value = "pipeline";
|
||||
select.dispatchEvent(new Event("change", { bubbles: true }));
|
||||
})()`);
|
||||
await eventually(
|
||||
() =>
|
||||
page.evaluate(`(() => {
|
||||
const rows = [...document.querySelectorAll("#searchResults .search-row")];
|
||||
return rows.length > 0 && rows.every((r) => r.dataset.kind === "pipeline");
|
||||
})()`),
|
||||
{ timeout: 25000, what: "the kind filter to narrow the list to pipelines" },
|
||||
);
|
||||
const filteredSummary = await text("#searchSummary");
|
||||
if (filteredSummary !== "Pipelines · Relevance") {
|
||||
throw new Error(`the filtered summary is wrong: ${filteredSummary}`);
|
||||
}
|
||||
const filteredRows = await page.evaluate(`document.querySelectorAll("#searchResults .search-row").length`);
|
||||
console.log(` Pipelines filter: ${filteredRows} row(s), summary "${filteredSummary}"`);
|
||||
await page.rect("#searchPanel");
|
||||
await shot("02-search-kind-filter.png");
|
||||
|
||||
step("Clear filter returns the kind to All kinds");
|
||||
await page.click("#searchClearFilter");
|
||||
await eventually(async () => (await text("#searchSummary")) === "All kinds · Relevance", {
|
||||
timeout: 15000,
|
||||
what: "Clear filter to reset the kind",
|
||||
});
|
||||
console.log(' Clear filter reset the kind to "All kinds"');
|
||||
|
||||
step("a Fields filter emphasises the matched snippet in the page, never as markup (S1)");
|
||||
await page.evaluate(`(() => {
|
||||
const select = document.querySelector("#searchKind");
|
||||
select.value = "field";
|
||||
select.dispatchEvent(new Event("change", { bubbles: true }));
|
||||
})()`);
|
||||
await eventually(
|
||||
() => page.evaluate(`!!document.querySelector("#searchResults .search-row .search-match")`),
|
||||
{ timeout: 25000, what: "an emphasised snippet span" },
|
||||
);
|
||||
const emphasis = await page.evaluate(`(() => {
|
||||
const node = document.querySelector("#searchResults .search-row .search-match");
|
||||
return {
|
||||
tag: node?.tagName ?? "",
|
||||
inner: node?.firstElementChild?.tagName ?? "",
|
||||
text: node?.textContent ?? "",
|
||||
kind: node?.closest(".search-row")?.dataset.kind ?? "",
|
||||
};
|
||||
})()`);
|
||||
if (emphasis.tag !== "STRONG" || emphasis.inner !== "U") {
|
||||
throw new Error(`the matched span is not <strong><u>: ${JSON.stringify(emphasis)}`);
|
||||
}
|
||||
if (!emphasis.text) throw new Error("the emphasised span carries no text");
|
||||
if (emphasis.kind !== "field") throw new Error(`the emphasis is not on a field hit: ${emphasis.kind}`);
|
||||
console.log(` matched snippet emphasised as <${emphasis.tag}><${emphasis.inner}>: "${emphasis.text}"`);
|
||||
// Back to every kind for the routing steps.
|
||||
await page.evaluate(`(() => {
|
||||
const select = document.querySelector("#searchKind");
|
||||
select.value = "";
|
||||
select.dispatchEvent(new Event("change", { bubbles: true }));
|
||||
})()`);
|
||||
await eventually(() => page.evaluate(`!!document.querySelector("#searchResults .search-row")`), {
|
||||
timeout: 25000,
|
||||
what: "the unfiltered list",
|
||||
});
|
||||
|
||||
step("routing a pipeline hit to its detail (S2)");
|
||||
const pipelineTarget = await routeSearchKind(SEARCH_QUERY, "pipeline", async () => {
|
||||
await page.waitForSelector("#content .detail h2", { timeout: 25000 });
|
||||
await page.waitForSelector("#content .detail .monospace", { timeout: 25000 });
|
||||
return true;
|
||||
});
|
||||
if (!pipelineTarget) throw new Error("no pipeline result routed to a pipeline detail");
|
||||
const pipelineView = await page.evaluate(`(() => ({
|
||||
active: document.querySelector("nav.tabs button.tab.active")?.textContent ?? "",
|
||||
title: document.querySelector("#content .detail h2")?.textContent ?? "",
|
||||
searchOpen: !!document.querySelector("#searchInput"),
|
||||
}))()`);
|
||||
if (!pipelineView.active.startsWith("Pipelines")) {
|
||||
throw new Error(`a pipeline hit landed on ${pipelineView.active}`);
|
||||
}
|
||||
if (!pipelineView.title) throw new Error("the routed pipeline detail has no heading");
|
||||
if (pipelineView.searchOpen) throw new Error("selecting a result did not close the search panel");
|
||||
console.log(` ${pipelineTarget} -> Pipelines detail "${pipelineView.title}"`);
|
||||
await page.rect("#content .detail");
|
||||
await shot("03-search-route-pipeline.png");
|
||||
|
||||
step("routing a run hit to its detail (S2)");
|
||||
const runTarget = await routeSearchKind(SEARCH_QUERY, "run", async () => {
|
||||
await eventually(
|
||||
() =>
|
||||
page.evaluate(`(() => {
|
||||
const tab = document.querySelector("nav.tabs button.tab.active")?.textContent ?? "";
|
||||
return tab.startsWith("Runs") && !!document.querySelector("#content .detail .detail-tabs");
|
||||
})()`),
|
||||
{ timeout: 25000, what: "the routed run detail" },
|
||||
);
|
||||
return true;
|
||||
});
|
||||
if (!runTarget) throw new Error("no run result routed to a run detail");
|
||||
const runView = await page.evaluate(`(() => ({
|
||||
active: document.querySelector("nav.tabs button.tab.active")?.textContent ?? "",
|
||||
title: document.querySelector("#content .detail h2")?.textContent ?? "",
|
||||
tabs: [...document.querySelectorAll("#content .detail .detail-tabs .detail-tab")].map((n) => n.textContent),
|
||||
}))()`);
|
||||
if (!runView.active.startsWith("Runs")) throw new Error(`a run hit landed on ${runView.active}`);
|
||||
if (!runView.tabs.includes("Summary")) throw new Error(`the routed run detail has no tabs: ${runView.tabs}`);
|
||||
console.log(` ${runTarget} -> Runs detail "${runView.title}" (${runView.tabs.join("/")})`);
|
||||
await page.rect("#content .detail");
|
||||
await shot("04-search-route-run.png");
|
||||
|
||||
step("routing a field hit to the run-detail tab holding the match (S2)");
|
||||
const fieldTargets = await searchTargets(SEARCH_QUERY, "field");
|
||||
let fieldRoute = null;
|
||||
for (const target of fieldTargets.slice(0, 4)) {
|
||||
// data-target is run:{id}:{sequence}:{matchedField}.
|
||||
const matchedField = target.split(":")[3] ?? "";
|
||||
const expectedTab = matchedField === "input" ? "Input" : matchedField === "output" ? "Output" : "Summary";
|
||||
await searchTargets(SEARCH_QUERY, "field");
|
||||
if (!(await clickSearchTarget(target))) continue;
|
||||
const landed = await eventually(
|
||||
() =>
|
||||
page.evaluate(`(() => {
|
||||
const tab = document.querySelector("nav.tabs button.tab.active")?.textContent ?? "";
|
||||
const active = document.querySelector("#content .detail .detail-tabs .detail-tab.active")?.textContent ?? "";
|
||||
return tab.startsWith("Runs") && active === ${JSON.stringify(expectedTab)};
|
||||
})()`),
|
||||
{ timeout: 25000, what: `the ${expectedTab} run-detail tab` },
|
||||
)
|
||||
.then(() => true)
|
||||
.catch(() => false);
|
||||
if (landed) {
|
||||
fieldRoute = { target, matchedField, expectedTab };
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!fieldRoute) throw new Error("no field result opened the run-detail tab holding its match");
|
||||
console.log(` ${fieldRoute.target} (matched_field ${fieldRoute.matchedField}) -> ${fieldRoute.expectedTab} tab`);
|
||||
await page.rect("#content .detail");
|
||||
await shot("05-search-route-field.png");
|
||||
|
||||
step("routing a step hit to the visit's stage pane (S2)");
|
||||
const stepTarget = await routeSearchKind(SEARCH_QUERY, "step", async () => {
|
||||
await eventually(() => page.evaluate(`!!document.querySelector(".stage-pane")`), {
|
||||
timeout: 20000,
|
||||
what: "the routed visit stage pane",
|
||||
});
|
||||
return true;
|
||||
});
|
||||
if (!stepTarget) throw new Error("no step result opened a visit stage pane");
|
||||
const stepPane = await page.evaluate(`(() => ({
|
||||
title: document.querySelector(".stage-pane-title")?.textContent ?? "",
|
||||
tab: document.querySelector("nav.tabs button.tab.active")?.textContent ?? "",
|
||||
}))()`);
|
||||
if (!stepPane.title) throw new Error("the routed stage pane named no stage");
|
||||
if (!stepPane.tab.startsWith("Runs")) throw new Error(`the step route landed on ${stepPane.tab}`);
|
||||
console.log(` ${stepTarget} -> run stage pane "${stepPane.title}"`);
|
||||
await page.rect(".stage-pane-sheet");
|
||||
await shot("06-search-route-step.png");
|
||||
await page.click(".stage-pane-back");
|
||||
await eventually(() => page.evaluate(`!document.querySelector(".stage-pane")`), {
|
||||
timeout: 5000,
|
||||
what: "the step stage pane to close",
|
||||
});
|
||||
|
||||
step("routing an artifact hit to the same visit pane (S2)");
|
||||
const artifactTarget = await routeSearchKind(SEARCH_QUERY, "artifact", async () => {
|
||||
await eventually(() => page.evaluate(`!!document.querySelector(".stage-pane")`), {
|
||||
timeout: 20000,
|
||||
what: "the routed artifact visit pane",
|
||||
});
|
||||
return true;
|
||||
});
|
||||
if (artifactTarget) {
|
||||
const artifactPane = await page.evaluate(
|
||||
`document.querySelector(".stage-pane-title")?.textContent ?? ""`,
|
||||
);
|
||||
console.log(` ${artifactTarget} -> run stage pane "${artifactPane}"`);
|
||||
await page.rect(".stage-pane-sheet");
|
||||
await shot("07-search-route-artifact.png");
|
||||
await page.click(".stage-pane-back");
|
||||
await eventually(() => page.evaluate(`!document.querySelector(".stage-pane")`), {
|
||||
timeout: 5000,
|
||||
what: "the artifact stage pane to close",
|
||||
});
|
||||
} else {
|
||||
console.log(" -- no artifact hit routed to a visit pane; skipped the artifact capture");
|
||||
}
|
||||
|
||||
step("routing a version hit to its pipeline detail (S2)");
|
||||
const versionTarget = await routeSearchKind(SEARCH_QUERY, "version", async () => {
|
||||
await eventually(
|
||||
() =>
|
||||
page.evaluate(`(() => {
|
||||
const tab = document.querySelector("nav.tabs button.tab.active")?.textContent ?? "";
|
||||
return tab.startsWith("Pipelines") && !!document.querySelector("#content .detail h2");
|
||||
})()`),
|
||||
{ timeout: 25000, what: "the pipeline detail for the version" },
|
||||
);
|
||||
return true;
|
||||
});
|
||||
if (versionTarget) {
|
||||
const versionTitle = await text("#content .detail h2");
|
||||
console.log(` ${versionTarget} -> Pipelines detail "${versionTitle}"`);
|
||||
await page.rect("#content .detail");
|
||||
await shot("08-search-route-version.png");
|
||||
} else {
|
||||
console.log(" -- no version hit routed; skipped the version capture");
|
||||
}
|
||||
|
||||
step("Closing search clears the query and leaves the view intact (S1)");
|
||||
await searchTargets("release", "field");
|
||||
const beforeClose = await viewSnapshot();
|
||||
await page.click("#searchClose");
|
||||
await eventually(() => page.evaluate(`!document.querySelector("#searchInput")`), {
|
||||
timeout: 10000,
|
||||
what: "the search panel to close",
|
||||
});
|
||||
const afterClose = await viewSnapshot();
|
||||
if (afterClose.tab !== beforeClose.tab || afterClose.detail !== beforeClose.detail) {
|
||||
throw new Error(`closing search changed the view: ${JSON.stringify({ beforeClose, afterClose })}`);
|
||||
}
|
||||
await page.click("#searchToggle");
|
||||
await page.waitForSelector("#searchInput", { timeout: 15000 });
|
||||
const reopenedQuery = await page.evaluate(`document.querySelector("#searchInput")?.value ?? ""`);
|
||||
if (reopenedQuery !== "") throw new Error(`closing search did not clear the query: "${reopenedQuery}"`);
|
||||
await page.evaluate(
|
||||
`document.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }))`,
|
||||
);
|
||||
await eventually(() => page.evaluate(`!document.querySelector("#searchInput")`), {
|
||||
timeout: 10000,
|
||||
what: "Escape to close the search",
|
||||
});
|
||||
console.log(" Close search cleared the query and kept the view; Escape also closed the field");
|
||||
|
||||
console.log("\nUI SMOKE PASS");
|
||||
for (const shot of shots) console.log(` ${shot}`);
|
||||
} catch (error) {
|
||||
|
||||
Reference in New Issue
Block a user