Files
pipelines/app/lib/features/runs/ui/run_search_selection.dart
T
alan 2d1cd743ee fix(app): keep a search selection one-shot and always reach Summary
A retired or unknown field hit now selects the plain Summary instead of
leaving an open visit pane in place, matching the browser's searchFieldTab
and Android. The resolved target is a sealed Summary/visit value, so the
field mapping lives in one place.

An unapplied request is dropped when the shell leaves the run it names, so
Backing out of a loading detail no longer replays the selection on a later,
unrelated visit. Search/Templates/Schedules pages above the run keep it.
2026-10-22 16:03:18 +01:00

127 lines
4.4 KiB
Dart

import 'package:flutter/widgets.dart';
import '../../../core/api_gateway.dart';
import 'run_detail_visit_facts.dart';
/// A search hit's requested selection inside one run's detail.
///
/// A recorded hit names only the run's own recorded [sequence] and, for a text
/// hit, the [field] it matched; the stage and timeline position are resolved
/// against the loaded detail, exactly as the browser client does. A request is
/// consumed once, so reopening the run later never replays it.
@immutable
class RunSearchSelection {
const RunSearchSelection({required this.runId, this.sequence, this.field});
final int runId;
/// The server's recorded visit number, or null when the hit names no visit.
final int? sequence;
/// The matched step field (`input`, `output`, …), or null for a visit hit.
final String? field;
@override
bool operator ==(Object other) =>
other is RunSearchSelection &&
other.runId == runId &&
other.sequence == sequence &&
other.field == field;
@override
int get hashCode => Object.hash(runId, sequence, field);
}
/// The collapsible Summary section a text hit names.
enum RunSummarySection { input, output }
/// What a resolved search request selects in the loaded run detail.
sealed class RunSearchTarget {
const RunSearchTarget();
}
/// The run Summary, optionally with the matched field's section expanded.
final class RunSummaryTarget extends RunSearchTarget {
const RunSummaryTarget({this.section});
/// The section a text hit matched, or null for the plain Summary.
final RunSummarySection? section;
}
/// One recorded visit: [stageKey] plus the detail row index the Timeline and
/// the Graph selection also use.
final class RunVisitTarget extends RunSearchTarget {
const RunVisitTarget({required this.stageKey, required this.timelineIndex});
final String stageKey;
final int timelineIndex;
}
/// Resolves [selection] against the loaded [run] into the detail state to show.
///
/// A text hit always selects the Summary, using the browser's `searchFieldTab`
/// mapping: `input` and `output` expand that section, while a retired or
/// unknown field leaves the plain Summary instead of guessing a section. A
/// visit hit selects the step with the recorded sequence; a sequence the run did
/// not record falls back to the plain Summary, as the browser does, so a stale
/// hit never leaves an unrelated visit pane open.
RunSearchTarget resolveRunSearchSelection(
RunSearchSelection selection,
JsonMap run,
) {
final field = selection.field?.trim() ?? '';
if (field.isNotEmpty) {
return RunSummaryTarget(
section: switch (field) {
'input' => RunSummarySection.input,
'output' => RunSummarySection.output,
_ => null,
},
);
}
final sequence = selection.sequence;
if (sequence != null && sequence > 0) {
final steps = detailRunSteps(run);
for (var index = 0; index < steps.length; index++) {
if (_sequence(steps[index]) != sequence) continue;
final stage = '${steps[index]['stage'] ?? ''}'.trim();
if (stage.isEmpty) break;
// The row index is the Timeline's own index, the identity the visit pane
// reads back through detailVisitStepAt, so no ordinal is guessed here.
return RunVisitTarget(stageKey: stage, timelineIndex: index);
}
}
return const RunSummaryTarget();
}
int? _sequence(JsonMap step) {
final value = step['sequence'];
final number = value is num ? value.toInt() : int.tryParse('${value ?? ''}');
return number != null && number > 0 ? number : null;
}
/// Carries the shell's one pending search request to the mounted run detail.
///
/// The composition mounts it around the shell; [RunDetailTabs] reads it and
/// reports [onConsumed] once the request has been applied, so a later visit to
/// the same run starts plain. Keeping the request here means a field or artifact
/// hit needs no invented URL: the browser has no route for either selection.
class RunSearchSelectionScope extends InheritedWidget {
const RunSearchSelectionScope({
super.key,
required this.selection,
required this.onConsumed,
required super.child,
});
final RunSearchSelection? selection;
final VoidCallback onConsumed;
static RunSearchSelectionScope? maybeOf(BuildContext context) =>
context.dependOnInheritedWidgetOfExactType<RunSearchSelectionScope>();
@override
bool updateShouldNotify(RunSearchSelectionScope oldWidget) =>
oldWidget.selection != selection || oldWidget.onConsumed != onConsumed;
}