Make the Android stage detail a pane and add an artifacts gallery
Turn the stage detail into the rightmost pane of a bounded three-level stack and show every run artifact in a summary gallery. - The stage detail opens as a real level-2 pane from both entry points (a Timeline row and a graph node). StageDetailPane is wrapped in the same Scaffold/TopAppBar with a back arrow as the other panes, and its identity/result facts (status, outcome, target, duration, visit, model target) render outside any collapsible so a fresh pane is never empty. StageDetailSheet, ModalBottomSheet and RightSlidingPanel are removed. - SlidingPaneStack replaces SlidingMasterDetail: pane 0 fills the host, panes 1 and 2 overlay at peek*level, each covered pane keeps one tappable peek strip, and MasterPane/backStep/popTo/MAX_PANE_DEPTH are the pure model. The peek tap, the pane back arrow, the system Back button and the predictive-back gesture all pop exactly one level. - New pure runArtifactGroups(steps) groups a run's artifacts by stage and visit (stable order, duplicates kept, empty run -> empty) and artifactsEmptyMessage distinguishes the running "capture pending" case. ArtifactGallery renders image thumbnails (tap opens full size) and non-image rows with name, size, content type and open/copy; urls resolve through ServerUrl, never a hardcoded host. - Run Summary shows the run gallery and the stage pane shows that visit's group, keeping the existing per-visit artifacts summary and notes. - Tests updated/added (PaneStateTest, SlidingPaneStackTest, ArtifactGroupsTest, ArtifactGalleryTest, StageDetailSheetTest, refreshed DetailTabsTest/PipelinesNavTest, CollapseRemovalTest kept green) and android/README.md records the pass, evidence and not-verified list.
This commit is contained in:
@@ -6,6 +6,7 @@
|
||||
|
||||
<application
|
||||
android:allowBackup="true"
|
||||
android:enableOnBackInvokedCallback="true"
|
||||
android:name=".PipelinesApplication"
|
||||
android:icon="@drawable/ic_launcher"
|
||||
android:label="@string/app_name"
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
package net.awan.pipelines.ui
|
||||
|
||||
import net.awan.pipelines.data.protocol.RunStep
|
||||
import net.awan.pipelines.data.protocol.StageArtifact
|
||||
import net.awan.pipelines.ui.screens.runTimeline
|
||||
|
||||
/**
|
||||
* Every artifact one visit of one stage recorded, in the order the visit's
|
||||
* artifacts were reported. Duplicate names are tolerated (kept, not deduped): an
|
||||
* artifact's identity is its recorded url, not its name.
|
||||
*/
|
||||
data class ArtifactGroup(
|
||||
val stageKey: String,
|
||||
val visit: Int,
|
||||
val artifacts: List<StageArtifact>,
|
||||
)
|
||||
|
||||
/**
|
||||
* Groups a run's artifacts by stage and visit, purely and deterministically.
|
||||
* Order follows [runTimeline]: stages in first-appearance order and each stage's
|
||||
* visits by sequence, with the same display visit number (the recorded control
|
||||
* visit, else the position within the stage). Only visits that recorded at least
|
||||
* one artifact produce a group, so an empty/absent capture never yields an empty
|
||||
* group and an artifact-less run yields an empty list. O(steps), single pass.
|
||||
*/
|
||||
fun runArtifactGroups(steps: List<RunStep>): List<ArtifactGroup> {
|
||||
if (steps.isEmpty()) return emptyList()
|
||||
val timeline = runTimeline(steps)
|
||||
// Reuse runTimeline's display visit number rather than re-deriving it: the
|
||||
// entries already carry (stage, sequence) -> visit. O(steps), built once.
|
||||
val visitByStageSequence = timeline.entries.associate { (it.stageKey to it.step.sequence) to it.visit }
|
||||
val groups = ArrayList<ArtifactGroup>()
|
||||
timeline.visitsByStage.forEach { (stageKey, visits) ->
|
||||
visits.forEach { step ->
|
||||
val artifacts = step.artifacts.orEmpty()
|
||||
if (artifacts.isNotEmpty()) {
|
||||
val visit = visitByStageSequence[stageKey to step.sequence] ?: 1
|
||||
groups += ArtifactGroup(stageKey, visit, artifacts)
|
||||
}
|
||||
}
|
||||
}
|
||||
return groups
|
||||
}
|
||||
|
||||
/**
|
||||
* The explicit message shown where the run's artifacts gallery would be when
|
||||
* there are none: while the run is executing it uses the same "capture pending"
|
||||
* wording as a running visit, otherwise it says plainly that nothing was
|
||||
* recorded.
|
||||
*/
|
||||
fun artifactsEmptyMessage(executing: Boolean): String =
|
||||
if (executing) {
|
||||
"Artifacts · $ARTIFACT_CAPTURE_PENDING"
|
||||
} else {
|
||||
"No artifacts recorded for this run."
|
||||
}
|
||||
@@ -110,6 +110,12 @@ fun humanBytes(size: Long): String {
|
||||
/** Whether an artifact's content type is an image the sheet can preview. */
|
||||
fun isImageContentType(contentType: String): Boolean = contentType.startsWith("image/")
|
||||
|
||||
/**
|
||||
* The "capture pending" wording shared by a running visit's summary and the
|
||||
* run-level empty state, so the two never spell it differently.
|
||||
*/
|
||||
const val ARTIFACT_CAPTURE_PENDING = "capture pending"
|
||||
|
||||
/**
|
||||
* The artifacts summary label, mirroring internal/tui/file_changes.go
|
||||
* artifactsSummary: "capture pending" while the visit runs, "not recorded for
|
||||
@@ -119,7 +125,11 @@ fun isImageContentType(contentType: String): Boolean = contentType.startsWith("i
|
||||
fun artifactsSummary(step: RunStep): String {
|
||||
val artifacts = step.artifacts.orEmpty()
|
||||
if (artifacts.isEmpty()) {
|
||||
val state = if (step.status == "running") "capture pending" else "not recorded for this visit"
|
||||
val state = if (step.status == "running") {
|
||||
ARTIFACT_CAPTURE_PENDING
|
||||
} else {
|
||||
"not recorded for this visit"
|
||||
}
|
||||
return "Artifacts · $state"
|
||||
}
|
||||
var label = "Artifacts · ${artifacts.size} recorded"
|
||||
|
||||
@@ -0,0 +1,112 @@
|
||||
package net.awan.pipelines.ui
|
||||
|
||||
import androidx.compose.runtime.saveable.Saver
|
||||
|
||||
/**
|
||||
* Which pane of the sliding stack is showing: the list (level 0), the selected
|
||||
* item's detail (level 1) and, when a stage/node is open, the stage pane
|
||||
* (level 2). The panes stack left to right and each leaves a peek of the pane it
|
||||
* covers.
|
||||
*/
|
||||
enum class MasterPane { List, Detail, Stage }
|
||||
|
||||
/**
|
||||
* The declared bound on the stack: list (0), detail (1), stage (2). The stack can
|
||||
* never grow deeper than this; selecting a different stage or list item replaces
|
||||
* the rightmost pane instead of pushing a new level.
|
||||
*/
|
||||
const val MAX_PANE_DEPTH = 2
|
||||
|
||||
/**
|
||||
* The saved pane-stack selection: which pane is rightmost, which item (0 = none),
|
||||
* its pipeline/run version, which detail section (page) is showing, and which
|
||||
* stage/visit the stage pane is on. Every field is a primitive, so the state
|
||||
* round-trips through a Bundle cheaply and survives rotation, configuration
|
||||
* change and process death.
|
||||
*
|
||||
* Geometry (peek width, insets, measured pane widths) is deliberately *not* part
|
||||
* of this model; it is derived from layout so nothing is hardcoded here.
|
||||
*/
|
||||
data class PaneSelection(
|
||||
val pane: MasterPane = MasterPane.List,
|
||||
val itemId: Long = 0L,
|
||||
val itemVersion: Int = 0,
|
||||
val sectionIndex: Int = 0,
|
||||
val stageKey: String? = null,
|
||||
val stageVisit: Int = 0,
|
||||
) {
|
||||
/** How many panes are stacked: 0 list, 1 detail, 2 stage. */
|
||||
val depth: Int
|
||||
get() = when (pane) {
|
||||
MasterPane.List -> 0
|
||||
MasterPane.Detail -> 1
|
||||
MasterPane.Stage -> 2
|
||||
}
|
||||
}
|
||||
|
||||
/** The result of one Back step: show a new selection, or leave the app. */
|
||||
sealed interface BackResult {
|
||||
/** The list is showing, so Back leaves the app (no pane to close). */
|
||||
data object Exit : BackResult
|
||||
|
||||
/** Show [selection] (exactly one pane level back). */
|
||||
data class Show(val selection: PaneSelection) : BackResult
|
||||
}
|
||||
|
||||
/**
|
||||
* Exactly one pane level of Back. Inside the stage pane it steps back to the
|
||||
* detail; inside the detail it steps back to the list; at the list it leaves the
|
||||
* app. Sections are navigated only by their own tab row/pager, never by Back, so
|
||||
* the peek tap and the Back button/gesture always pop the same single level.
|
||||
*/
|
||||
fun backStep(selection: PaneSelection): BackResult = when (selection.pane) {
|
||||
MasterPane.List -> BackResult.Exit
|
||||
MasterPane.Detail -> BackResult.Show(PaneSelection(pane = MasterPane.List))
|
||||
MasterPane.Stage -> BackResult.Show(
|
||||
selection.copy(pane = MasterPane.Detail, stageKey = null, stageVisit = 0),
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* The selection after tapping the peek of the pane at [level]: every pane to its
|
||||
* right is closed. Level 0 (the list) shows a bare list; level 1 shows the same
|
||||
* item's detail with no stage; a [level] at or beyond the current depth is a
|
||||
* no-op (there is nothing to its right).
|
||||
*/
|
||||
fun popTo(selection: PaneSelection, level: Int): PaneSelection = when {
|
||||
level <= 0 -> PaneSelection()
|
||||
level == 1 -> selection.copy(pane = MasterPane.Detail, stageKey = null, stageVisit = 0)
|
||||
else -> selection
|
||||
}
|
||||
|
||||
/**
|
||||
* Encodes a [PaneSelection] as Bundle-able primitives (a small `List<Any>`), so
|
||||
* the saved state stays tiny. Paired with [decodePaneSelection].
|
||||
*/
|
||||
internal fun encodePaneSelection(selection: PaneSelection): List<Any> = listOf(
|
||||
selection.pane.name,
|
||||
selection.itemId,
|
||||
selection.itemVersion,
|
||||
selection.sectionIndex,
|
||||
selection.stageKey ?: "",
|
||||
selection.stageVisit,
|
||||
)
|
||||
|
||||
/** Restores a [PaneSelection] encoded by [encodePaneSelection]. */
|
||||
internal fun decodePaneSelection(encoded: List<Any>): PaneSelection = PaneSelection(
|
||||
pane = MasterPane.valueOf(encoded[0] as String),
|
||||
itemId = encoded[1] as Long,
|
||||
itemVersion = encoded[2] as Int,
|
||||
sectionIndex = encoded[3] as Int,
|
||||
stageKey = (encoded[4] as String).takeIf { it.isNotEmpty() },
|
||||
stageVisit = encoded[5] as Int,
|
||||
)
|
||||
|
||||
/**
|
||||
* Saves/restores a [PaneSelection] across configuration change and process
|
||||
* death. The save payload is primitives only (see [encodePaneSelection]).
|
||||
*/
|
||||
val PaneSelectionSaver: Saver<PaneSelection, List<Any>> = Saver(
|
||||
save = { encodePaneSelection(it) },
|
||||
restore = { decodePaneSelection(it) },
|
||||
)
|
||||
@@ -1,5 +1,6 @@
|
||||
package net.awan.pipelines.ui
|
||||
|
||||
import androidx.activity.compose.PredictiveBackHandler
|
||||
import androidx.compose.foundation.background
|
||||
import androidx.compose.foundation.layout.Arrangement
|
||||
import androidx.compose.foundation.layout.Box
|
||||
@@ -7,33 +8,25 @@ import androidx.compose.foundation.layout.Column
|
||||
import androidx.compose.foundation.layout.Row
|
||||
import androidx.compose.foundation.layout.WindowInsets
|
||||
import androidx.compose.foundation.layout.consumeWindowInsets
|
||||
import androidx.compose.foundation.layout.fillMaxHeight
|
||||
import androidx.compose.foundation.layout.fillMaxSize
|
||||
import androidx.compose.foundation.layout.navigationBars
|
||||
import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.layout.size
|
||||
import androidx.compose.foundation.layout.statusBars
|
||||
import androidx.compose.foundation.layout.width
|
||||
import androidx.compose.foundation.layout.windowInsetsPadding
|
||||
import androidx.compose.foundation.selection.selectable
|
||||
import androidx.compose.foundation.shape.CircleShape
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.automirrored.filled.KeyboardArrowLeft
|
||||
import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
|
||||
import androidx.compose.material.icons.filled.AccountTree
|
||||
import androidx.compose.material.icons.filled.History
|
||||
import androidx.compose.material.icons.filled.Settings
|
||||
import androidx.compose.material3.Icon
|
||||
import androidx.compose.material3.IconButton
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.Scaffold
|
||||
import androidx.compose.material3.Surface
|
||||
import androidx.compose.material3.VerticalDivider
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableIntStateOf
|
||||
import androidx.compose.runtime.mutableLongStateOf
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.saveable.rememberSaveable
|
||||
import androidx.compose.runtime.setValue
|
||||
@@ -46,15 +39,19 @@ import androidx.compose.ui.platform.LocalConfiguration
|
||||
import androidx.compose.ui.semantics.Role
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.lifecycle.compose.collectAsStateWithLifecycle
|
||||
import androidx.navigation.NavType
|
||||
import androidx.navigation.compose.NavHost
|
||||
import androidx.navigation.compose.composable
|
||||
import androidx.navigation.compose.currentBackStackEntryAsState
|
||||
import androidx.navigation.compose.rememberNavController
|
||||
import androidx.navigation.navArgument
|
||||
import kotlinx.coroutines.flow.collect
|
||||
import net.awan.pipelines.data.transport.ConnectionState
|
||||
import net.awan.pipelines.ui.components.ConnectionBanner
|
||||
import net.awan.pipelines.ui.components.EmptyState
|
||||
import net.awan.pipelines.ui.components.SlidingPaneStack
|
||||
import net.awan.pipelines.ui.components.clampTabIndex
|
||||
import net.awan.pipelines.ui.components.pipelineDetailTabs
|
||||
import net.awan.pipelines.ui.components.runDetailTabs
|
||||
import net.awan.pipelines.ui.graph.PipelineStagePane
|
||||
import net.awan.pipelines.ui.graph.RunStagePane
|
||||
import net.awan.pipelines.ui.screens.PipelineDetailScreen
|
||||
import net.awan.pipelines.ui.screens.PipelineListScreen
|
||||
import net.awan.pipelines.ui.screens.RunDetailScreen
|
||||
@@ -70,14 +67,23 @@ private val destinations = listOf(
|
||||
)
|
||||
|
||||
/**
|
||||
* Whether [route]'s destination is the current one. A detail route
|
||||
* (`pipeline/…`/`run/…`) belongs to its list destination, so the floating pill
|
||||
* keeps the right destination selected while a detail is open.
|
||||
* Whether [route] is the current destination. Detail panes are no longer
|
||||
* separate routes (they are saved state inside a destination), so this is a
|
||||
* plain equality check.
|
||||
*/
|
||||
internal fun destinationSelected(currentRoute: String?, route: String): Boolean =
|
||||
currentRoute == route ||
|
||||
(route == "pipelines" && currentRoute?.startsWith("pipeline/") == true) ||
|
||||
(route == "runs" && currentRoute?.startsWith("run/") == true)
|
||||
currentRoute == route
|
||||
|
||||
/**
|
||||
* One Back step as a selection update. The peek tap, the detail's top-bar back
|
||||
* button and the system Back button/gesture all call through here, so a section
|
||||
* never disagrees with the pane.
|
||||
*/
|
||||
private fun backFrom(selection: PaneSelection): PaneSelection =
|
||||
when (val result = backStep(selection)) {
|
||||
is BackResult.Show -> result.selection
|
||||
BackResult.Exit -> selection
|
||||
}
|
||||
|
||||
@Composable
|
||||
fun PipelinesApp(vm: AppViewModel) {
|
||||
@@ -86,10 +92,16 @@ fun PipelinesApp(vm: AppViewModel) {
|
||||
val currentRoute = backStackEntry?.destination?.route
|
||||
val connectionState by vm.connectionState.collectAsStateWithLifecycle()
|
||||
val configuredUrl by vm.configuredServerUrl.collectAsStateWithLifecycle()
|
||||
// Window-size driven (never a hardcoded device): a foldable's narrow cover
|
||||
// display stays single-pane, its wide inner display shows list + detail.
|
||||
// Window-size driven (never a hardcoded device): the same sliding pane works at
|
||||
// every width; only the section index presentation (tab row vs rail) changes.
|
||||
val wide = isWideLayout(LocalConfiguration.current.screenWidthDp)
|
||||
|
||||
// The Runs destination's selection is hoisted here so the Pipelines detail can
|
||||
// jump to a freshly started run (there is no longer a run route to navigate to).
|
||||
var runSelection by rememberSaveable(stateSaver = PaneSelectionSaver) {
|
||||
mutableStateOf(PaneSelection())
|
||||
}
|
||||
|
||||
val onNavigate: (TopDestination) -> Unit = { destination ->
|
||||
if (currentRoute != destination.route) {
|
||||
navController.navigate(destination.route) {
|
||||
@@ -134,47 +146,24 @@ fun PipelinesApp(vm: AppViewModel) {
|
||||
),
|
||||
) {
|
||||
composable("pipelines") {
|
||||
if (wide) {
|
||||
WidePipelinePane(
|
||||
vm = vm,
|
||||
onOpenRun = { runId -> navController.navigate("run/$runId") },
|
||||
)
|
||||
} else {
|
||||
PipelineListScreen(vm, onOpen = { id, version ->
|
||||
navController.navigate("pipeline/$id/$version")
|
||||
})
|
||||
}
|
||||
}
|
||||
composable(
|
||||
route = "pipeline/{id}/{version}",
|
||||
arguments = listOf(
|
||||
navArgument("id") { type = NavType.LongType },
|
||||
navArgument("version") { type = NavType.IntType },
|
||||
),
|
||||
) { entry ->
|
||||
PipelineDetailScreen(
|
||||
PipelineDestination(
|
||||
vm = vm,
|
||||
pipelineId = entry.arguments?.getLong("id") ?: 0L,
|
||||
version = entry.arguments?.getInt("version") ?: 0,
|
||||
onBack = { navController.popBackStack() },
|
||||
onOpenRun = { runId -> navController.navigate("run/$runId") },
|
||||
wide = wide,
|
||||
onOpenRun = { runId ->
|
||||
runSelection = PaneSelection(
|
||||
pane = MasterPane.Detail,
|
||||
itemId = runId,
|
||||
)
|
||||
navController.navigate("runs") { launchSingleTop = true }
|
||||
},
|
||||
)
|
||||
}
|
||||
composable("runs") {
|
||||
if (wide) {
|
||||
WideRunPane(vm)
|
||||
} else {
|
||||
RunHistoryScreen(vm, onOpenRun = { runId -> navController.navigate("run/$runId") })
|
||||
}
|
||||
}
|
||||
composable(
|
||||
route = "run/{id}",
|
||||
arguments = listOf(navArgument("id") { type = NavType.LongType }),
|
||||
) { entry ->
|
||||
RunDetailScreen(
|
||||
RunsDestination(
|
||||
vm = vm,
|
||||
runId = entry.arguments?.getLong("id") ?: 0L,
|
||||
onBack = { navController.popBackStack() },
|
||||
wide = wide,
|
||||
selection = runSelection,
|
||||
onSelectionChange = { runSelection = it },
|
||||
)
|
||||
}
|
||||
composable("settings") {
|
||||
@@ -195,6 +184,138 @@ fun PipelinesApp(vm: AppViewModel) {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The Pipelines destination: one sliding pane stack whose pane 0 is the pipeline
|
||||
* list, pane 1 is the selected pipeline (Summary/Graph/Source) and pane 2 is the
|
||||
* stage pane for a graph node. The saved [PaneSelection] survives rotation,
|
||||
* configuration change and process death. Back (gesture/button) and the nearest
|
||||
* peek tap both step back exactly one level via [backFrom]; tapping a lower peek
|
||||
* closes every pane to its right via [popTo].
|
||||
*/
|
||||
@Composable
|
||||
private fun PipelineDestination(vm: AppViewModel, wide: Boolean, onOpenRun: (Long) -> Unit) {
|
||||
var selection by rememberSaveable(stateSaver = PaneSelectionSaver) {
|
||||
mutableStateOf(PaneSelection())
|
||||
}
|
||||
val depth = selection.depth
|
||||
val onBack: () -> Unit = { selection = backFrom(selection) }
|
||||
|
||||
PredictiveBackHandler(enabled = depth >= 1) { progress ->
|
||||
// Consume the gesture; on completion perform exactly one Back step.
|
||||
progress.collect { }
|
||||
onBack()
|
||||
}
|
||||
|
||||
SlidingPaneStack(
|
||||
depth = depth,
|
||||
onPopTo = { level -> selection = popTo(selection, level) },
|
||||
backContentDescription = { level -> if (level == 0) "Back to pipelines" else "Back to pipeline" },
|
||||
pane = { level, paneModifier ->
|
||||
when (level) {
|
||||
0 -> PipelineListScreen(
|
||||
vm = vm,
|
||||
onOpen = { id, version ->
|
||||
selection = PaneSelection(MasterPane.Detail, id, version)
|
||||
},
|
||||
modifier = paneModifier,
|
||||
selectedId = selection.itemId.takeIf { depth >= 1 },
|
||||
)
|
||||
1 -> if (selection.itemId != 0L) {
|
||||
PipelineDetailScreen(
|
||||
vm = vm,
|
||||
pipelineId = selection.itemId,
|
||||
version = selection.itemVersion,
|
||||
onBack = onBack,
|
||||
onOpenRun = onOpenRun,
|
||||
selectedSection = clampTabIndex(selection.sectionIndex, pipelineDetailTabs.size),
|
||||
onSelectSection = { selection = selection.copy(sectionIndex = it) },
|
||||
modifier = paneModifier,
|
||||
wide = wide,
|
||||
onOpenStage = { key ->
|
||||
selection = selection.copy(pane = MasterPane.Stage, stageKey = key, stageVisit = 0)
|
||||
},
|
||||
)
|
||||
}
|
||||
2 -> selection.stageKey?.let { key ->
|
||||
PipelineStagePane(
|
||||
vm = vm,
|
||||
pipelineId = selection.itemId,
|
||||
version = selection.itemVersion,
|
||||
stageKey = key,
|
||||
onBack = onBack,
|
||||
wide = wide,
|
||||
modifier = paneModifier,
|
||||
)
|
||||
}
|
||||
}
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* The Runs destination: the same shared pane stack with the run list, the
|
||||
* selected run's tabs and the stage pane. Its selection is owned by
|
||||
* [PipelinesApp] so the Pipelines detail can open a run it just started.
|
||||
*/
|
||||
@Composable
|
||||
private fun RunsDestination(
|
||||
vm: AppViewModel,
|
||||
wide: Boolean,
|
||||
selection: PaneSelection,
|
||||
onSelectionChange: (PaneSelection) -> Unit,
|
||||
) {
|
||||
val depth = selection.depth
|
||||
val onBack: () -> Unit = { onSelectionChange(backFrom(selection)) }
|
||||
|
||||
PredictiveBackHandler(enabled = depth >= 1) { progress ->
|
||||
progress.collect { }
|
||||
onBack()
|
||||
}
|
||||
|
||||
SlidingPaneStack(
|
||||
depth = depth,
|
||||
onPopTo = { level -> onSelectionChange(popTo(selection, level)) },
|
||||
backContentDescription = { level -> if (level == 0) "Back to runs" else "Back to run" },
|
||||
pane = { level, paneModifier ->
|
||||
when (level) {
|
||||
0 -> RunHistoryScreen(
|
||||
vm = vm,
|
||||
onOpenRun = { runId -> onSelectionChange(PaneSelection(MasterPane.Detail, runId)) },
|
||||
modifier = paneModifier,
|
||||
selectedRunId = selection.itemId.takeIf { depth >= 1 },
|
||||
)
|
||||
1 -> if (selection.itemId != 0L) {
|
||||
RunDetailScreen(
|
||||
vm = vm,
|
||||
runId = selection.itemId,
|
||||
onBack = onBack,
|
||||
selectedSection = clampTabIndex(selection.sectionIndex, runDetailTabs.size),
|
||||
onSelectSection = { onSelectionChange(selection.copy(sectionIndex = it)) },
|
||||
modifier = paneModifier,
|
||||
wide = wide,
|
||||
onOpenStage = { key, visit ->
|
||||
onSelectionChange(
|
||||
selection.copy(pane = MasterPane.Stage, stageKey = key, stageVisit = visit),
|
||||
)
|
||||
},
|
||||
)
|
||||
}
|
||||
2 -> selection.stageKey?.let { key ->
|
||||
RunStagePane(
|
||||
vm = vm,
|
||||
runId = selection.itemId,
|
||||
stageKey = key,
|
||||
visitIndex = selection.stageVisit,
|
||||
onBack = onBack,
|
||||
wide = wide,
|
||||
modifier = paneModifier,
|
||||
)
|
||||
}
|
||||
}
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* The Pipelines/Runs/Settings destinations as a floating rounded pill at the
|
||||
* bottom right: the three destinations as icons, inset from the bottom/right
|
||||
@@ -258,124 +379,6 @@ private fun DestinationPill(
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Wide Pipelines destination: the pipeline list beside the selected pipeline's
|
||||
* tabs. The selection is remembered across config changes and Back inside the
|
||||
* detail clears it (rather than popping a route that is not on the stack). The
|
||||
* list pane collapses to a narrow strip (remembered/saved across configuration
|
||||
* changes); the freed width goes to the detail.
|
||||
*/
|
||||
@Composable
|
||||
private fun WidePipelinePane(vm: AppViewModel, onOpenRun: (Long) -> Unit) {
|
||||
var selectedId by rememberSaveable { mutableStateOf<Long?>(null) }
|
||||
var selectedVersion by rememberSaveable { mutableIntStateOf(0) }
|
||||
var paneExpanded by rememberSaveable { mutableStateOf(true) }
|
||||
Row(Modifier.fillMaxSize()) {
|
||||
if (paneExpanded) {
|
||||
Box(Modifier.width(LIST_PANE_WIDTH).fillMaxHeight()) {
|
||||
PipelineListScreen(
|
||||
vm,
|
||||
onOpen = { id, version ->
|
||||
selectedId = id
|
||||
selectedVersion = version
|
||||
},
|
||||
selectedId = selectedId,
|
||||
onTogglePane = { paneExpanded = false },
|
||||
)
|
||||
}
|
||||
VerticalDivider()
|
||||
} else {
|
||||
CollapsedListPane(paneExpanded = false, onToggle = { paneExpanded = true })
|
||||
VerticalDivider()
|
||||
}
|
||||
Box(Modifier.weight(1f).fillMaxHeight()) {
|
||||
val id = selectedId
|
||||
if (id == null) {
|
||||
EmptyState("Select a pipeline to see its Summary, Graph and Source.")
|
||||
} else {
|
||||
PipelineDetailScreen(
|
||||
vm = vm,
|
||||
pipelineId = id,
|
||||
version = selectedVersion,
|
||||
onBack = { selectedId = null },
|
||||
onOpenRun = onOpenRun,
|
||||
wide = true,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Wide Runs destination: the run list beside the selected run's tabs. The
|
||||
* selection is remembered across config changes and Back inside the detail clears
|
||||
* it instead of popping. The list pane collapses to a narrow strip exactly like
|
||||
* the pipelines pane.
|
||||
*/
|
||||
@Composable
|
||||
private fun WideRunPane(vm: AppViewModel) {
|
||||
var selectedRunId by rememberSaveable { mutableLongStateOf(0L) }
|
||||
var paneExpanded by rememberSaveable { mutableStateOf(true) }
|
||||
Row(Modifier.fillMaxSize()) {
|
||||
if (paneExpanded) {
|
||||
Box(Modifier.width(LIST_PANE_WIDTH).fillMaxHeight()) {
|
||||
RunHistoryScreen(
|
||||
vm,
|
||||
onOpenRun = { selectedRunId = it },
|
||||
selectedRunId = selectedRunId,
|
||||
onTogglePane = { paneExpanded = false },
|
||||
)
|
||||
}
|
||||
VerticalDivider()
|
||||
} else {
|
||||
CollapsedListPane(paneExpanded = false, onToggle = { paneExpanded = true })
|
||||
VerticalDivider()
|
||||
}
|
||||
Box(Modifier.weight(1f).fillMaxHeight()) {
|
||||
if (selectedRunId == 0L) {
|
||||
EmptyState("Select a run to see its Summary, Graph, Input, Output, Evidence and Timeline.")
|
||||
} else {
|
||||
RunDetailScreen(
|
||||
vm = vm,
|
||||
runId = selectedRunId,
|
||||
onBack = { selectedRunId = 0L },
|
||||
wide = true,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The collapsed list pane: a narrow strip holding only the control that restores
|
||||
* the pane, with an accurate accessibility label. Reuses the tab rail's
|
||||
* chevron-toggle idiom.
|
||||
*/
|
||||
@Composable
|
||||
private fun CollapsedListPane(paneExpanded: Boolean, onToggle: () -> Unit) {
|
||||
Column(
|
||||
modifier = Modifier.width(COLLAPSED_LIST_PANE_WIDTH).fillMaxHeight(),
|
||||
horizontalAlignment = Alignment.CenterHorizontally,
|
||||
) {
|
||||
IconButton(onClick = onToggle, modifier = Modifier.padding(top = 8.dp)) {
|
||||
Icon(
|
||||
imageVector = if (paneExpanded) {
|
||||
Icons.AutoMirrored.Filled.KeyboardArrowLeft
|
||||
} else {
|
||||
Icons.AutoMirrored.Filled.KeyboardArrowRight
|
||||
},
|
||||
contentDescription = if (paneExpanded) "Collapse list pane" else "Expand list pane",
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Width of the master list pane in the wide two-pane layout. */
|
||||
private val LIST_PANE_WIDTH = 360.dp
|
||||
|
||||
/** Width of the collapsed master list pane (its restore control only). */
|
||||
private val COLLAPSED_LIST_PANE_WIDTH = 56.dp
|
||||
|
||||
/** Bottom space reserved for the floating destination pill, so content is never
|
||||
* permanently hidden behind it (pill height + its margins + a small gap). */
|
||||
private val DESTINATION_PILL_RESERVE = 88.dp
|
||||
|
||||
@@ -12,13 +12,13 @@ import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.layout.size
|
||||
import androidx.compose.foundation.layout.width
|
||||
import androidx.compose.foundation.layout.widthIn
|
||||
import androidx.compose.foundation.pager.HorizontalPager
|
||||
import androidx.compose.foundation.pager.rememberPagerState
|
||||
import androidx.compose.foundation.selection.selectable
|
||||
import androidx.compose.foundation.selection.selectableGroup
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.automirrored.filled.FactCheck
|
||||
import androidx.compose.material.icons.automirrored.filled.Input
|
||||
import androidx.compose.material.icons.automirrored.filled.KeyboardArrowLeft
|
||||
import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
|
||||
import androidx.compose.material.icons.automirrored.filled.List
|
||||
import androidx.compose.material.icons.automirrored.filled.Send
|
||||
import androidx.compose.material.icons.filled.Code
|
||||
@@ -26,19 +26,21 @@ import androidx.compose.material.icons.filled.Hub
|
||||
import androidx.compose.material.icons.filled.Info
|
||||
import androidx.compose.material3.ExperimentalMaterial3Api
|
||||
import androidx.compose.material3.Icon
|
||||
import androidx.compose.material3.IconButton
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.PrimaryScrollableTabRow
|
||||
import androidx.compose.material3.Tab
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.material3.VerticalDivider
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.LaunchedEffect
|
||||
import androidx.compose.runtime.Stable
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.remember
|
||||
import androidx.compose.runtime.rememberUpdatedState
|
||||
import androidx.compose.runtime.saveable.Saver
|
||||
import androidx.compose.runtime.saveable.rememberSaveable
|
||||
import androidx.compose.runtime.snapshotFlow
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
@@ -47,12 +49,12 @@ import androidx.compose.ui.graphics.vector.ImageVector
|
||||
import androidx.compose.ui.semantics.Role
|
||||
import androidx.compose.ui.text.style.TextOverflow
|
||||
import androidx.compose.ui.unit.dp
|
||||
import kotlinx.coroutines.flow.distinctUntilChanged
|
||||
import net.awan.pipelines.ui.theme.pipelinesText
|
||||
|
||||
/**
|
||||
* A named detail page tab: [key] is stable for `when` dispatch, [title] is shown,
|
||||
* and [icon] is the tab's glyph (used on the wide rail, always alongside the
|
||||
* label when expanded and alone when it is collapsed).
|
||||
* and [icon] is the tab's glyph on the wide rail.
|
||||
*/
|
||||
data class DetailTab(val key: String, val title: String, val icon: ImageVector)
|
||||
|
||||
@@ -81,15 +83,19 @@ fun clampTabIndex(index: Int, tabCount: Int): Int =
|
||||
if (tabCount <= 0) 0 else index.coerceIn(0, tabCount - 1)
|
||||
|
||||
/**
|
||||
* A tab host that renders the tab strip and *only* the selected tab's content
|
||||
* (the caller's `when`), so switching tabs never composes every tab at once.
|
||||
* The section index + its panel, open to the right. On narrow windows the index
|
||||
* is a horizontally scrolling Material 3 [PrimaryScrollableTabRow]; on wide
|
||||
* windows it is an always-visible selectable rail. Both stay fixed and visible
|
||||
* while the sections themselves live in a [HorizontalPager], so tapping a
|
||||
* section slides its panel in from the right (and a later section enters from the
|
||||
* right, an earlier one from the left as the pager follows the index order);
|
||||
* swiping switches sections too.
|
||||
*
|
||||
* Narrow windows get a horizontally scrolling Material 3 [PrimaryScrollableTabRow]
|
||||
* (the run detail's six tabs scroll on a cover display); wide windows get a
|
||||
* vertical selectable rail that collapses to a narrow icon-only strip and expands
|
||||
* back to icons with labels, remembered across configuration changes. Both carry
|
||||
* real tab semantics (`Role.Tab` + selected state), so selection is never
|
||||
* conveyed by colour alone.
|
||||
* The pager composes only the visible page at rest (the default
|
||||
* `beyondViewportPageCount`), preserving the previous laziness. `selectedIndex`
|
||||
* is the single source of truth: a change from outside (e.g. Back) scrolls the
|
||||
* pager, and a settled pager (a tap or a swipe) reports the new index through
|
||||
* [onSelect]. The two are guarded against feedback loops.
|
||||
*/
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
@@ -101,34 +107,50 @@ fun DetailTabs(
|
||||
modifier: Modifier = Modifier,
|
||||
content: @Composable (DetailTab, Modifier) -> Unit,
|
||||
) {
|
||||
val selected = clampTabIndex(selectedIndex, tabs.size)
|
||||
if (tabs.isEmpty()) return
|
||||
val selected = clampTabIndex(selectedIndex, tabs.size)
|
||||
val pagerState = rememberPagerState(initialPage = selected, pageCount = { tabs.size })
|
||||
|
||||
// External selection (Back, or a restored index) moves the pager; skip while
|
||||
// a finger is down so a swipe is never fought mid-gesture.
|
||||
LaunchedEffect(selected, tabs.size) {
|
||||
if (!pagerState.isScrollInProgress && pagerState.settledPage != selected) {
|
||||
pagerState.animateScrollToPage(selected)
|
||||
}
|
||||
}
|
||||
// A settled pager (tab tap or swipe) reports the section up. Keyed only on the
|
||||
// pager so it is never restarted; the callback is read through a fresh state.
|
||||
val report by rememberUpdatedState(onSelect)
|
||||
LaunchedEffect(pagerState) {
|
||||
snapshotFlow { pagerState.settledPage }
|
||||
.distinctUntilChanged()
|
||||
.collect { report(it) }
|
||||
}
|
||||
|
||||
val page: @Composable (Int) -> Unit = { index ->
|
||||
content(tabs[clampTabIndex(index, tabs.size)], Modifier.fillMaxSize())
|
||||
}
|
||||
|
||||
if (wide) {
|
||||
// Remembered/saved so the collapsed or expanded rail survives
|
||||
// recomposition and configuration changes.
|
||||
var railExpanded by rememberSaveable { mutableStateOf(true) }
|
||||
Row(modifier.fillMaxSize()) {
|
||||
Column(
|
||||
modifier = Modifier
|
||||
.width(railWidthDp(railExpanded).dp)
|
||||
.width(WIDE_RAIL_WIDTH_DP.dp)
|
||||
.fillMaxHeight()
|
||||
.padding(vertical = 8.dp),
|
||||
) {
|
||||
RailToggle(expanded = railExpanded, onToggle = { railExpanded = !railExpanded })
|
||||
Column(
|
||||
modifier = Modifier
|
||||
.weight(1f)
|
||||
.fillMaxWidth()
|
||||
.selectableGroup()
|
||||
.padding(top = 4.dp, bottom = 8.dp),
|
||||
.padding(top = 8.dp, bottom = 8.dp),
|
||||
verticalArrangement = Arrangement.spacedBy(4.dp),
|
||||
) {
|
||||
tabs.forEachIndexed { index, tab ->
|
||||
RailTab(
|
||||
tab = tab,
|
||||
selected = index == selected,
|
||||
expanded = railExpanded,
|
||||
onClick = { onSelect(index) },
|
||||
)
|
||||
}
|
||||
@@ -136,7 +158,9 @@ fun DetailTabs(
|
||||
}
|
||||
VerticalDivider()
|
||||
Box(Modifier.weight(1f).fillMaxHeight()) {
|
||||
content(tabs[selected], Modifier.fillMaxSize())
|
||||
HorizontalPager(state = pagerState, modifier = Modifier.fillMaxSize()) { index ->
|
||||
page(index)
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
@@ -150,41 +174,22 @@ fun DetailTabs(
|
||||
)
|
||||
}
|
||||
}
|
||||
Box(Modifier.weight(1f).fillMaxWidth()) {
|
||||
content(tabs[selected], Modifier.fillMaxSize())
|
||||
HorizontalPager(
|
||||
state = pagerState,
|
||||
modifier = Modifier.weight(1f).fillMaxWidth(),
|
||||
) { index ->
|
||||
page(index)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** The accessibility-labelled control that collapses/expands the wide rail. */
|
||||
@Composable
|
||||
private fun RailToggle(expanded: Boolean, onToggle: () -> Unit) {
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth().padding(horizontal = 4.dp),
|
||||
horizontalArrangement = if (expanded) Arrangement.End else Arrangement.Center,
|
||||
) {
|
||||
IconButton(onClick = onToggle) {
|
||||
Icon(
|
||||
imageVector = if (expanded) {
|
||||
Icons.AutoMirrored.Filled.KeyboardArrowLeft
|
||||
} else {
|
||||
Icons.AutoMirrored.Filled.KeyboardArrowRight
|
||||
},
|
||||
contentDescription = if (expanded) "Collapse tabs" else "Expand tabs",
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* One wide-rail tab. Expanded it is an icon+label row; collapsed it is an
|
||||
* icon-only tile whose icon carries the [DetailTab.title] as its content
|
||||
* description. Selection is conveyed by the tab semantics (Role.Tab + selected)
|
||||
* and the container colour, not colour alone.
|
||||
* One wide-rail tab: an icon+label row. Selection is conveyed by the tab
|
||||
* semantics (Role.Tab + selected) and the container colour, not colour alone.
|
||||
*/
|
||||
@Composable
|
||||
private fun RailTab(tab: DetailTab, selected: Boolean, expanded: Boolean, onClick: () -> Unit) {
|
||||
private fun RailTab(tab: DetailTab, selected: Boolean, onClick: () -> Unit) {
|
||||
val text = pipelinesText()
|
||||
val contentColor = if (selected) {
|
||||
MaterialTheme.colorScheme.onSecondaryContainer
|
||||
@@ -198,31 +203,24 @@ private fun RailTab(tab: DetailTab, selected: Boolean, expanded: Boolean, onClic
|
||||
.background(
|
||||
if (selected) MaterialTheme.colorScheme.secondaryContainer else Color.Transparent,
|
||||
)
|
||||
.padding(horizontal = if (expanded) 16.dp else 0.dp, vertical = 12.dp),
|
||||
.padding(horizontal = 16.dp, vertical = 12.dp),
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
horizontalArrangement = if (expanded) {
|
||||
Arrangement.spacedBy(12.dp)
|
||||
} else {
|
||||
Arrangement.Center
|
||||
},
|
||||
horizontalArrangement = Arrangement.spacedBy(12.dp),
|
||||
) {
|
||||
Icon(
|
||||
imageVector = tab.icon,
|
||||
// When expanded the label names the tab, so the glyph is decorative;
|
||||
// collapsed the glyph is the only visible affordance and names it.
|
||||
contentDescription = if (expanded) null else tab.title,
|
||||
// The label names the tab, so the glyph is decorative.
|
||||
contentDescription = null,
|
||||
tint = contentColor,
|
||||
modifier = Modifier.size(24.dp),
|
||||
)
|
||||
if (expanded) {
|
||||
Text(
|
||||
text = tab.title,
|
||||
style = text.cardTitle,
|
||||
color = contentColor,
|
||||
maxLines = 1,
|
||||
overflow = TextOverflow.Ellipsis,
|
||||
)
|
||||
}
|
||||
Text(
|
||||
text = tab.title,
|
||||
style = text.cardTitle,
|
||||
color = contentColor,
|
||||
maxLines = 1,
|
||||
overflow = TextOverflow.Ellipsis,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -281,12 +279,8 @@ fun rememberSectionExpansion(vararg inputs: Any?): SectionExpansionState {
|
||||
return remember(expanded) { SectionExpansionState(expanded) }
|
||||
}
|
||||
|
||||
/** The always-visible wide section rail's width (icons with labels). */
|
||||
private const val WIDE_RAIL_WIDTH_DP = 200
|
||||
private const val COLLAPSED_RAIL_WIDTH_DP = 64
|
||||
|
||||
/** Rail width in dp: icons with labels when expanded, icon-only when collapsed. */
|
||||
internal fun railWidthDp(expanded: Boolean): Int =
|
||||
if (expanded) WIDE_RAIL_WIDTH_DP else COLLAPSED_RAIL_WIDTH_DP
|
||||
|
||||
/** Comfortable max text width for a tab body on a wide window. */
|
||||
const val DETAIL_MAX_WIDTH_DP = 840
|
||||
|
||||
@@ -0,0 +1,175 @@
|
||||
package net.awan.pipelines.ui.components
|
||||
|
||||
import androidx.compose.animation.core.animateDpAsState
|
||||
import androidx.compose.animation.core.spring
|
||||
import androidx.compose.foundation.clickable
|
||||
import androidx.compose.foundation.layout.Box
|
||||
import androidx.compose.foundation.layout.BoxWithConstraints
|
||||
import androidx.compose.foundation.layout.WindowInsets
|
||||
import androidx.compose.foundation.layout.asPaddingValues
|
||||
import androidx.compose.foundation.layout.fillMaxHeight
|
||||
import androidx.compose.foundation.layout.fillMaxSize
|
||||
import androidx.compose.foundation.layout.height
|
||||
import androidx.compose.foundation.layout.offset
|
||||
import androidx.compose.foundation.layout.systemBars
|
||||
import androidx.compose.foundation.layout.systemGestures
|
||||
import androidx.compose.foundation.layout.union
|
||||
import androidx.compose.foundation.layout.width
|
||||
import androidx.compose.material3.LocalMinimumInteractiveComponentSize
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.input.pointer.PointerEventPass
|
||||
import androidx.compose.ui.input.pointer.pointerInput
|
||||
import androidx.compose.ui.platform.LocalLayoutDirection
|
||||
import androidx.compose.ui.semantics.Role
|
||||
import androidx.compose.ui.semantics.clearAndSetSemantics
|
||||
import androidx.compose.ui.semantics.contentDescription
|
||||
import androidx.compose.ui.semantics.role
|
||||
import androidx.compose.ui.semantics.semantics
|
||||
import androidx.compose.ui.unit.Dp
|
||||
import androidx.compose.ui.unit.dp
|
||||
import net.awan.pipelines.ui.MAX_PANE_DEPTH
|
||||
|
||||
/**
|
||||
* The one named minimum width of the visible peek strip left of an open pane.
|
||||
* The actual peek is derived from this and the platform's minimum interactive
|
||||
* size, widened further by the left system-gesture inset so the *tappable* strip
|
||||
* (after that inset) is still at least the minimum interactive size.
|
||||
*/
|
||||
private val PEEK_WIDTH_DP = 56.dp
|
||||
|
||||
/**
|
||||
* The visible peek width: at least [PEEK_WIDTH_DP], and always wide enough that
|
||||
* the tappable strip left after [startInset] is at least [minimumInteractive].
|
||||
* Pure so the geometry is unit-testable without a device.
|
||||
*/
|
||||
internal fun peekWidthDp(minimumInteractive: Dp, startInset: Dp = 0.dp): Dp =
|
||||
maxOf(PEEK_WIDTH_DP, minimumInteractive + startInset)
|
||||
|
||||
/**
|
||||
* The x offset of pane [level] when it is open: one peek per level, so each
|
||||
* covered pane keeps exactly one peek visible. Derived, never a magic offset.
|
||||
*/
|
||||
internal fun paneOffsetDp(level: Int, peek: Dp): Dp = peek * level
|
||||
|
||||
/**
|
||||
* The width of pane [level]: the measured host width minus the peeks it leaves
|
||||
* visible to its left. Derived from the measured width, never hardcoded.
|
||||
*/
|
||||
internal fun paneWidthDp(hostWidth: Dp, level: Int, peek: Dp): Dp =
|
||||
maxOf(0.dp, hostWidth - peek * level)
|
||||
|
||||
/**
|
||||
* The one shared sliding pane stack: pane 0 (the list) fills the host and each
|
||||
* deeper pane overlays the one below, sliding in from the right until a peek
|
||||
* strip of the pane it covers stays visible on the left. Both the Pipelines and
|
||||
* Runs destinations use this, so the motion and geometry live in exactly one
|
||||
* place, and the stage pane is the same third level as the detail.
|
||||
*
|
||||
* [depth] is the number of visible panes minus one (0..[MAX_PANE_DEPTH]);
|
||||
* [pane] composes the level's content and is expected to render nothing for a
|
||||
* level whose selection is empty (so a closing pane simply slides back out).
|
||||
* Tapping a covered pane's peek calls [onPopTo] with that pane's level, closing
|
||||
* every pane to its right; [backContentDescription] names each strip.
|
||||
*
|
||||
* Every pane is always composed and each level has its own long-lived
|
||||
* [animateDpAsState], so opening slides in and closing slides back out with no
|
||||
* first-frame hack, and a rapid run of taps only retargets an existing animator
|
||||
* (never half-slid). A covered pane is hidden from accessibility and made
|
||||
* non-interactive so TalkBack focus follows the top pane and a tap can never leak
|
||||
* through to a covered one; only its peek strip stays tappable.
|
||||
*/
|
||||
@Composable
|
||||
fun SlidingPaneStack(
|
||||
depth: Int,
|
||||
onPopTo: (Int) -> Unit,
|
||||
modifier: Modifier = Modifier,
|
||||
backContentDescription: (Int) -> String = { "Back" },
|
||||
pane: @Composable (level: Int, modifier: Modifier) -> Unit,
|
||||
) {
|
||||
BoxWithConstraints(modifier.fillMaxSize()) {
|
||||
// Measured once per layout. The insets are read once here and applied to
|
||||
// the strip node's geometry (not via a padding modifier, which would
|
||||
// shrink the pointer node to nothing once the gesture insets are wide).
|
||||
val hostWidth = maxWidth
|
||||
val insetPadding = WindowInsets.systemBars.union(WindowInsets.systemGestures)
|
||||
.asPaddingValues()
|
||||
val direction = LocalLayoutDirection.current
|
||||
val startInset = insetPadding.calculateLeftPadding(direction)
|
||||
val topInset = insetPadding.calculateTopPadding()
|
||||
val bottomInset = insetPadding.calculateBottomPadding()
|
||||
val peek = peekWidthDp(LocalMinimumInteractiveComponentSize.current, startInset)
|
||||
|
||||
// Pane 0 fills the host; it is blocked as soon as anything covers it.
|
||||
pane(
|
||||
0,
|
||||
Modifier
|
||||
.fillMaxSize()
|
||||
.then(if (depth >= 1) Modifier.blockPointerInput() else Modifier),
|
||||
)
|
||||
|
||||
// Panes 1..MAX are always composed (the animator stays warm); a level
|
||||
// beyond the depth sits off-screen and the caller renders nothing.
|
||||
for (level in 1..MAX_PANE_DEPTH) {
|
||||
val covered = level - 1
|
||||
if (covered < depth) {
|
||||
// The covered pane's tappable peek: clear of the status/nav bars,
|
||||
// of the left gesture area (startInset) and, via the peek
|
||||
// derivation, at least the minimum interactive size. Tapping it
|
||||
// closes every pane to its right.
|
||||
val stripOffset = if (covered == 0) startInset else peek * covered
|
||||
val stripWidth = if (covered == 0) peek - startInset else peek
|
||||
Box(
|
||||
Modifier
|
||||
.align(Alignment.TopStart)
|
||||
.offset(x = stripOffset, y = topInset)
|
||||
.width(maxOf(0.dp, stripWidth))
|
||||
.height(maxOf(0.dp, maxHeight - topInset - bottomInset))
|
||||
.clickable(
|
||||
role = Role.Button,
|
||||
onClickLabel = backContentDescription(covered),
|
||||
onClick = { onPopTo(covered) },
|
||||
)
|
||||
.semantics {
|
||||
contentDescription = backContentDescription(covered)
|
||||
role = Role.Button
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
val offset by animateDpAsState(
|
||||
targetValue = if (level <= depth) paneOffsetDp(level, peek) else hostWidth,
|
||||
animationSpec = spring(),
|
||||
label = "pane-slide-$level",
|
||||
)
|
||||
Box(
|
||||
Modifier
|
||||
.offset(x = offset)
|
||||
.width(paneWidthDp(hostWidth, level, peek))
|
||||
.fillMaxHeight()
|
||||
.then(if (level < depth) Modifier.blockPointerInput() else Modifier),
|
||||
) {
|
||||
pane(level, Modifier.fillMaxSize())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Clears a pane's semantics and consumes every pointer event, so a covered pane
|
||||
* is neither reachable by TalkBack nor tappable through the peek strip above it.
|
||||
* Consuming in the Initial pass stops the pane's own rows (which would otherwise
|
||||
* handle the event first, bottom-up); a peek strip is a separate, higher sibling
|
||||
* and is the only node hit where it sits, so its tap is never affected.
|
||||
*/
|
||||
private fun Modifier.blockPointerInput(): Modifier = this
|
||||
.clearAndSetSemantics { }
|
||||
.pointerInput(Unit) {
|
||||
awaitPointerEventScope {
|
||||
while (true) {
|
||||
awaitPointerEvent(PointerEventPass.Initial).changes.forEach { it.consume() }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,7 @@ import android.net.Uri
|
||||
import androidx.compose.foundation.clickable
|
||||
import androidx.compose.foundation.layout.Arrangement
|
||||
import androidx.compose.foundation.layout.Box
|
||||
import androidx.compose.foundation.layout.BoxWithConstraints
|
||||
import androidx.compose.foundation.layout.Column
|
||||
import androidx.compose.foundation.layout.Row
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
@@ -16,7 +17,6 @@ import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.automirrored.filled.InsertDriveFile
|
||||
import androidx.compose.material.icons.automirrored.filled.OpenInNew
|
||||
import androidx.compose.material.icons.filled.ContentCopy
|
||||
import androidx.compose.material.icons.filled.Image
|
||||
import androidx.compose.material3.Icon
|
||||
import androidx.compose.material3.IconButton
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
@@ -34,11 +34,13 @@ import androidx.compose.ui.platform.LocalClipboardManager
|
||||
import androidx.compose.ui.platform.LocalContext
|
||||
import androidx.compose.ui.text.AnnotatedString
|
||||
import androidx.compose.ui.text.style.TextOverflow
|
||||
import androidx.compose.ui.unit.Dp
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.compose.ui.window.Dialog
|
||||
import net.awan.pipelines.data.protocol.RunStep
|
||||
import net.awan.pipelines.data.protocol.StageArtifact
|
||||
import net.awan.pipelines.data.transport.ServerUrl
|
||||
import net.awan.pipelines.ui.ArtifactGroup
|
||||
import net.awan.pipelines.ui.artifactCaptureNotes
|
||||
import net.awan.pipelines.ui.artifactMetaLine
|
||||
import net.awan.pipelines.ui.artifactsSummary
|
||||
@@ -46,10 +48,11 @@ import net.awan.pipelines.ui.isImageContentType
|
||||
import net.awan.pipelines.ui.theme.pipelinesText
|
||||
|
||||
/**
|
||||
* The per-visit artifacts section for the stage detail sheet: the summary line
|
||||
* (matching the TUI's empty/partial wording), one row per file, and the
|
||||
* partial-capture notes. The single artifacts rendering path; it resolves each
|
||||
* url against the configured server URL and never hardcodes a host.
|
||||
* The per-visit artifacts section for the stage pane: the summary line (matching
|
||||
* the TUI's empty/partial wording), the capture notes, and the visit's own
|
||||
* artifacts rendered through the shared [ArtifactGallery]. The single artifacts
|
||||
* rendering path; it resolves each url against the configured server URL and
|
||||
* never hardcodes a host.
|
||||
*
|
||||
* When no server URL is configured the rows still show (name/size/type) but the
|
||||
* open/copy actions are disabled and a hint is shown.
|
||||
@@ -74,19 +77,136 @@ internal fun ArtifactsSection(
|
||||
style = text.meta,
|
||||
)
|
||||
}
|
||||
artifacts.forEach { artifact ->
|
||||
ArtifactRow(artifact, configuredServerUrl, fetchArtifactBytes)
|
||||
}
|
||||
notes.forEach { note -> Text(note, style = text.meta) }
|
||||
if (artifacts.isNotEmpty()) {
|
||||
// The section is already scoped to this visit, so no group header.
|
||||
val visit = step.control?.visit?.takeIf { it > 0 } ?: 1
|
||||
ArtifactGallery(
|
||||
groups = listOf(ArtifactGroup(step.stage, visit, artifacts)),
|
||||
configuredServerUrl = configuredServerUrl,
|
||||
fetchArtifactBytes = fetchArtifactBytes,
|
||||
showHeaders = false,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** One artifact: a type thumbnail (or inline preview), name, size/type, actions. */
|
||||
/**
|
||||
* The artifacts gallery: one group per (stage, visit) with a header, the group's
|
||||
* image artifacts as a grid of thumbnails (a tap opens the full-size view) and
|
||||
* its non-image artifacts as rows with name, size, content type and open/copy.
|
||||
* Every url is resolved with [ServerUrl.resolveArtifactUrl], so nothing here
|
||||
* hardcodes a host. The grid is built from non-lazy chunked [Row]s, so it never
|
||||
* nests a scrollable inside the Summary [LazyColumn] or the pane's scroll.
|
||||
*
|
||||
* The tile side is derived from the measured width (one [BoxWithConstraints]):
|
||||
* a fixed tile would overflow a narrow phone pane, so each tile is the widest
|
||||
* that fits the row up to the preferred [ARTIFACT_TILE_DP].
|
||||
*/
|
||||
@Composable
|
||||
internal fun ArtifactGallery(
|
||||
groups: List<ArtifactGroup>,
|
||||
configuredServerUrl: String,
|
||||
fetchArtifactBytes: suspend (String) -> ByteArray?,
|
||||
modifier: Modifier = Modifier,
|
||||
showHeaders: Boolean = true,
|
||||
) {
|
||||
val text = pipelinesText()
|
||||
BoxWithConstraints(modifier.fillMaxWidth()) {
|
||||
val tile = artifactTileDp(
|
||||
availableWidth = maxWidth,
|
||||
columns = ARTIFACT_GRID_COLUMNS,
|
||||
spacing = ARTIFACT_TILE_SPACING_DP,
|
||||
preferred = ARTIFACT_TILE_DP,
|
||||
)
|
||||
Column(Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||
groups.forEach { group ->
|
||||
if (showHeaders) {
|
||||
Text(
|
||||
"${group.stageKey} · visit ${group.visit}",
|
||||
style = text.sectionHeader,
|
||||
)
|
||||
}
|
||||
val images = group.artifacts.filter { isImageContentType(it.contentType) }
|
||||
val others = group.artifacts.filterNot { isImageContentType(it.contentType) }
|
||||
images.chunked(ARTIFACT_GRID_COLUMNS).forEach { rowArtifacts ->
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
horizontalArrangement = Arrangement.spacedBy(ARTIFACT_TILE_SPACING_DP),
|
||||
) {
|
||||
rowArtifacts.forEach { artifact ->
|
||||
ArtifactTile(artifact, configuredServerUrl, fetchArtifactBytes, tile)
|
||||
}
|
||||
// Keep a partial last row's tiles aligned to the grid.
|
||||
repeat(ARTIFACT_GRID_COLUMNS - rowArtifacts.size) {
|
||||
Box(Modifier.size(tile))
|
||||
}
|
||||
}
|
||||
}
|
||||
others.forEach { artifact ->
|
||||
ArtifactRow(artifact, configuredServerUrl)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The side of one square gallery tile: the widest that fits [columns] tiles and
|
||||
* their gaps in [availableWidth], capped at the preferred [preferred] so a wide
|
||||
* window keeps compact thumbnails and a narrow one keeps every tile fully on
|
||||
* screen. Pure, so the fitting is unit-tested without a device.
|
||||
*/
|
||||
internal fun artifactTileDp(availableWidth: Dp, columns: Int, spacing: Dp, preferred: Dp): Dp {
|
||||
if (columns <= 0) return preferred
|
||||
val fit = (availableWidth - spacing * (columns - 1)) / columns
|
||||
return fit.coerceIn(0.dp, preferred)
|
||||
}
|
||||
|
||||
/** One image artifact as a square thumbnail that opens the full-size view. */
|
||||
@Composable
|
||||
private fun ArtifactTile(
|
||||
artifact: StageArtifact,
|
||||
configuredServerUrl: String,
|
||||
fetchArtifactBytes: suspend (String) -> ByteArray?,
|
||||
tile: Dp,
|
||||
) {
|
||||
// Resolve once per (url, configuration), not on every recomposition.
|
||||
val resolved = remember(artifact.url, configuredServerUrl) {
|
||||
ServerUrl.resolveArtifactUrl(configuredServerUrl, artifact.url)
|
||||
}
|
||||
var showFull by remember(artifact.url) { mutableStateOf(false) }
|
||||
|
||||
Box(
|
||||
Modifier
|
||||
.size(tile)
|
||||
.clip(RoundedCornerShape(12.dp))
|
||||
.clickable(enabled = resolved != null) { showFull = true },
|
||||
) {
|
||||
ArtifactImage(
|
||||
url = resolved ?: artifact.url,
|
||||
contentDescription = "Preview of ${artifact.name}",
|
||||
maxDim = THUMBNAIL_MAX_DIM,
|
||||
fetchBytes = fetchArtifactBytes,
|
||||
size = tile,
|
||||
)
|
||||
}
|
||||
|
||||
if (showFull && resolved != null) {
|
||||
FullSizeArtifactDialog(
|
||||
url = resolved,
|
||||
name = artifact.name,
|
||||
fetchBytes = fetchArtifactBytes,
|
||||
onDismiss = { showFull = false },
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/** One non-image artifact: a file glyph, name, size/type and open/copy actions. */
|
||||
@Composable
|
||||
private fun ArtifactRow(
|
||||
artifact: StageArtifact,
|
||||
configuredServerUrl: String,
|
||||
fetchArtifactBytes: suspend (String) -> ByteArray?,
|
||||
) {
|
||||
val text = pipelinesText()
|
||||
val context = LocalContext.current
|
||||
@@ -95,9 +215,7 @@ private fun ArtifactRow(
|
||||
val resolved = remember(artifact.url, configuredServerUrl) {
|
||||
ServerUrl.resolveArtifactUrl(configuredServerUrl, artifact.url)
|
||||
}
|
||||
val isImage = remember(artifact.contentType) { isImageContentType(artifact.contentType) }
|
||||
val metaLine = remember(artifact) { artifactMetaLine(artifact) }
|
||||
var showFull by remember(artifact.url) { mutableStateOf(false) }
|
||||
|
||||
Surface(
|
||||
shape = RoundedCornerShape(12.dp),
|
||||
@@ -109,25 +227,15 @@ private fun ArtifactRow(
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
horizontalArrangement = Arrangement.spacedBy(12.dp),
|
||||
) {
|
||||
val thumbModifier = Modifier
|
||||
.size(56.dp)
|
||||
.clip(RoundedCornerShape(8.dp))
|
||||
if (isImage && resolved != null) {
|
||||
ArtifactImage(
|
||||
url = resolved,
|
||||
contentDescription = "Preview of ${artifact.name}",
|
||||
maxDim = THUMBNAIL_MAX_DIM,
|
||||
fetchBytes = fetchArtifactBytes,
|
||||
modifier = thumbModifier.clickable { showFull = true },
|
||||
Box(
|
||||
Modifier.size(56.dp).clip(RoundedCornerShape(8.dp)),
|
||||
contentAlignment = Alignment.Center,
|
||||
) {
|
||||
Icon(
|
||||
imageVector = Icons.AutoMirrored.Filled.InsertDriveFile,
|
||||
contentDescription = null,
|
||||
tint = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
)
|
||||
} else {
|
||||
Box(thumbModifier, contentAlignment = Alignment.Center) {
|
||||
Icon(
|
||||
imageVector = if (isImage) Icons.Default.Image else Icons.AutoMirrored.Filled.InsertDriveFile,
|
||||
contentDescription = null,
|
||||
tint = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
)
|
||||
}
|
||||
}
|
||||
Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) {
|
||||
Text(
|
||||
@@ -157,15 +265,6 @@ private fun ArtifactRow(
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (showFull && resolved != null) {
|
||||
FullSizeArtifactDialog(
|
||||
url = resolved,
|
||||
name = artifact.name,
|
||||
fetchBytes = fetchArtifactBytes,
|
||||
onDismiss = { showFull = false },
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/** The explicit full-resolution view, opened by tapping an image thumbnail. */
|
||||
@@ -216,3 +315,12 @@ private const val THUMBNAIL_MAX_DIM = 160
|
||||
|
||||
/** Fixed box for the full-size preview. */
|
||||
private const val FULL_SIZE_PREVIEW_DP = 320
|
||||
|
||||
/** Preferred side of one square gallery thumbnail tile (the named size token). */
|
||||
private val ARTIFACT_TILE_DP = 96.dp
|
||||
|
||||
/** Gap between gallery thumbnails; shared by the row arrangement and the fitting. */
|
||||
private val ARTIFACT_TILE_SPACING_DP = 8.dp
|
||||
|
||||
/** Image thumbnails per gallery row. */
|
||||
private const val ARTIFACT_GRID_COLUMNS = 3
|
||||
|
||||
+224
-66
@@ -1,33 +1,35 @@
|
||||
package net.awan.pipelines.ui.graph
|
||||
|
||||
import androidx.compose.foundation.layout.Arrangement
|
||||
import androidx.compose.foundation.layout.Box
|
||||
import androidx.compose.foundation.layout.Column
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.layout.widthIn
|
||||
import androidx.compose.foundation.rememberScrollState
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.foundation.verticalScroll
|
||||
import androidx.compose.material3.BottomSheetDefaults
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.automirrored.filled.ArrowBack
|
||||
import androidx.compose.material3.ExperimentalMaterial3Api
|
||||
import androidx.compose.material3.Icon
|
||||
import androidx.compose.material3.IconButton
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.ModalBottomSheet
|
||||
import androidx.compose.material3.PrimaryScrollableTabRow
|
||||
import androidx.compose.material3.Scaffold
|
||||
import androidx.compose.material3.Surface
|
||||
import androidx.compose.material3.Tab
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.material3.rememberModalBottomSheetState
|
||||
import androidx.compose.material3.TopAppBar
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableIntStateOf
|
||||
import androidx.compose.runtime.remember
|
||||
import androidx.compose.runtime.saveable.rememberSaveable
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.semantics.heading
|
||||
import androidx.compose.ui.semantics.semantics
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.lifecycle.compose.collectAsStateWithLifecycle
|
||||
import net.awan.pipelines.data.protocol.ControlEvidence
|
||||
import net.awan.pipelines.data.protocol.Graph
|
||||
import net.awan.pipelines.data.protocol.GraphSemantics
|
||||
@@ -35,25 +37,29 @@ import net.awan.pipelines.data.protocol.Protocol
|
||||
import net.awan.pipelines.data.protocol.RunStep
|
||||
import net.awan.pipelines.data.protocol.Stage
|
||||
import net.awan.pipelines.data.protocol.edges
|
||||
import net.awan.pipelines.ui.AppViewModel
|
||||
import net.awan.pipelines.ui.components.CodeBlock
|
||||
import net.awan.pipelines.ui.components.DETAIL_MAX_WIDTH_DP
|
||||
import net.awan.pipelines.ui.components.DetailTabBody
|
||||
import net.awan.pipelines.ui.components.KeyValueRow
|
||||
import net.awan.pipelines.ui.components.SectionHeader
|
||||
import net.awan.pipelines.ui.components.rememberSectionExpansion
|
||||
import net.awan.pipelines.ui.displayMap
|
||||
import net.awan.pipelines.ui.fileChangeLine
|
||||
import net.awan.pipelines.ui.fileChangesSummary
|
||||
import net.awan.pipelines.ui.formatDuration
|
||||
import net.awan.pipelines.ui.notificationLine
|
||||
import net.awan.pipelines.ui.screens.runTimeline
|
||||
import net.awan.pipelines.ui.theme.pipelinesText
|
||||
|
||||
/**
|
||||
* The effective stage type, mirroring internal/stage.EffectiveType: a blank type
|
||||
* is the model stage. Kept pure so the sheet chip and the node description share
|
||||
* is the model stage. Kept pure so the pane chip and the node description share
|
||||
* one derivation.
|
||||
*/
|
||||
internal fun effectiveStageType(type: String?): String =
|
||||
if (type.isNullOrBlank()) "model" else type
|
||||
|
||||
/** One labelled row/block of stage detail, rendered by the sheet. */
|
||||
/** One labelled row/block of stage detail, rendered by the pane. */
|
||||
internal data class StageField(
|
||||
val label: String,
|
||||
val value: String,
|
||||
@@ -64,7 +70,7 @@ internal data class StageField(
|
||||
/**
|
||||
* The pure definition view of a [stage]: key + type title, prompt, output, edges
|
||||
* with their outcomes and resolved terminals, configs, tools, limits and memory
|
||||
* sources. Only non-blank fields are emitted, so the sheet never shows an empty
|
||||
* sources. Only non-blank fields are emitted, so the pane never shows an empty
|
||||
* row and no protocol field is invented.
|
||||
*/
|
||||
internal fun stageDefinitionFields(stage: Stage): List<StageField> {
|
||||
@@ -117,7 +123,7 @@ internal fun stageDefinitionFields(stage: Stage): List<StageField> {
|
||||
|
||||
/**
|
||||
* The shared visit label for a step's control evidence, e.g. `3 / 5 (limit
|
||||
* reached)` (or just `3` when no max is recorded). Used by the sheet and the run
|
||||
* reached)` (or just `3` when no max is recorded). Used by the pane and the run
|
||||
* steps timeline so the two never spell a visit differently.
|
||||
*/
|
||||
internal fun controlVisitLabel(control: ControlEvidence): String {
|
||||
@@ -129,6 +135,27 @@ internal fun controlVisitLabel(control: ControlEvidence): String {
|
||||
return base + if (control.limitReached) " (limit reached)" else ""
|
||||
}
|
||||
|
||||
/**
|
||||
* The identity/result labels that must be visible the moment the stage pane is
|
||||
* opened, before anything is expanded: the stage's status and outcome, its
|
||||
* target, duration, visit and model target. Everything else lives in a
|
||||
* collapsible section.
|
||||
*/
|
||||
internal val STAGE_HEADLINE_LABELS: Set<String> =
|
||||
setOf("Status", "Outcome", "Target", "Duration", "Visit", "Model target")
|
||||
|
||||
/** The always-visible identity/result fields of a step's recorded evidence. */
|
||||
internal fun headlineFields(fields: List<StageField>): List<StageField> =
|
||||
fields.filter { it.label in STAGE_HEADLINE_LABELS }
|
||||
|
||||
/**
|
||||
* The remaining run evidence (diagnostic, transcript, session/agent, file
|
||||
* changes, notifications) that belongs in a collapsible section: the headline
|
||||
* facts and the input/output blocks are surfaced elsewhere.
|
||||
*/
|
||||
internal fun evidenceFields(fields: List<StageField>): List<StageField> =
|
||||
fields.filter { it.label !in STAGE_HEADLINE_LABELS && it.label != "Input" && it.label != "Output" }
|
||||
|
||||
/**
|
||||
* The pure run view of one [RunStep] for the selected stage: status, outcome,
|
||||
* duration, visit against the control's max_visits, target, session id,
|
||||
@@ -180,7 +207,7 @@ internal fun runStepFields(step: RunStep): List<StageField> {
|
||||
return fields
|
||||
}
|
||||
|
||||
/** Incoming routes into a terminal node, for the sheet opened on a terminal. */
|
||||
/** Incoming routes into a terminal node, for the pane opened on a terminal. */
|
||||
internal fun terminalFields(graph: Graph, key: String): List<StageField> {
|
||||
val lines = graph.edges()
|
||||
.filter { it.target == key }
|
||||
@@ -218,34 +245,75 @@ internal fun clampVisitIndex(index: Int, visitCount: Int): Int =
|
||||
internal fun showVisitTabs(visitCount: Int): Boolean = visitCount > 1
|
||||
|
||||
/**
|
||||
* The one reusable stage-detail overlay, opened when a node in [WorkflowGraph]
|
||||
* is tapped or a timeline entry is tapped. It is a Material 3
|
||||
* [ModalBottomSheet] that opens near full height (`skipPartiallyExpanded`), is
|
||||
* scrollable, and dismisses by swipe, back or tapping outside. On a wide window
|
||||
* it reuses the screens' responsive centring (the shared [DETAIL_MAX_WIDTH_DP])
|
||||
* instead of stretching one narrow column. It is an overlay on the current
|
||||
* screen; no navigation route is added.
|
||||
* The stage pane's content: opened as the rightmost level of the sliding stack
|
||||
* from a timeline entry or a graph node, exactly like the list and detail panes,
|
||||
* so there is no popup anywhere. It carries its own [Scaffold]/[TopAppBar] with a
|
||||
* back arrow that pops one level (the same step as the peek tap and system Back).
|
||||
*
|
||||
* [runSteps] is every recorded visit of the stage in order; when there is more
|
||||
* than one the sheet shows a visit tab row (visit 1..N) and starts on
|
||||
* than one the pane shows a visit tab row (visit 1..N) and starts on
|
||||
* [initialVisitIndex] (the tapped timeline entry, or the most recent visit when
|
||||
* opened from the graph). A stage the run never reached has no run section.
|
||||
* opened from the graph). A stage the run never reached has no run section; the
|
||||
* identity heading and type always show, so a freshly opened pane never reads as
|
||||
* empty.
|
||||
*/
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
fun StageDetailSheet(
|
||||
fun StageDetailPane(
|
||||
stageKey: String,
|
||||
graph: Graph,
|
||||
runSteps: List<RunStep> = emptyList(),
|
||||
initialVisitIndex: Int = 0,
|
||||
configuredServerUrl: String = "",
|
||||
fetchArtifactBytes: suspend (String) -> ByteArray? = { null },
|
||||
onDismiss: () -> Unit,
|
||||
onBack: () -> Unit,
|
||||
wide: Boolean = false,
|
||||
modifier: Modifier = Modifier,
|
||||
) {
|
||||
Scaffold(
|
||||
modifier = modifier,
|
||||
topBar = {
|
||||
TopAppBar(
|
||||
title = { Text(GraphSemantics.nodeLabel(stageKey)) },
|
||||
navigationIcon = {
|
||||
IconButton(onClick = onBack) {
|
||||
Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = "Back")
|
||||
}
|
||||
},
|
||||
)
|
||||
},
|
||||
) { padding ->
|
||||
StageDetailBody(
|
||||
stageKey = stageKey,
|
||||
graph = graph,
|
||||
runSteps = runSteps,
|
||||
initialVisitIndex = initialVisitIndex,
|
||||
configuredServerUrl = configuredServerUrl,
|
||||
fetchArtifactBytes = fetchArtifactBytes,
|
||||
wide = wide,
|
||||
modifier = Modifier.padding(padding),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/** The stage detail's content, wrapped by [StageDetailPane]. */
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
private fun StageDetailBody(
|
||||
stageKey: String,
|
||||
graph: Graph,
|
||||
runSteps: List<RunStep>,
|
||||
initialVisitIndex: Int,
|
||||
configuredServerUrl: String,
|
||||
fetchArtifactBytes: suspend (String) -> ByteArray?,
|
||||
wide: Boolean,
|
||||
modifier: Modifier = Modifier,
|
||||
) {
|
||||
val text = pipelinesText()
|
||||
val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
|
||||
val stage = graph.stages.firstOrNull { it.key == stageKey }
|
||||
val definition = stage?.let(::stageDefinitionFields) ?: terminalFields(graph, stageKey)
|
||||
val definition = remember(stage, graph, stageKey) {
|
||||
stage?.let(::stageDefinitionFields) ?: terminalFields(graph, stageKey)
|
||||
}
|
||||
val typeLabel = if (stage != null) effectiveStageType(stage.type) else "terminal"
|
||||
|
||||
// Reset the selected visit when the stage (but not the user's tap within it)
|
||||
@@ -255,64 +323,150 @@ fun StageDetailSheet(
|
||||
}
|
||||
val clampedVisit = clampVisitIndex(visitIndex, runSteps.size)
|
||||
val selectedStep = runSteps.getOrNull(clampedVisit)
|
||||
val run = selectedStep?.let(::runStepFields).orEmpty()
|
||||
// Derived once per selected step, not per recomposition.
|
||||
val runFields = remember(selectedStep) { selectedStep?.let(::runStepFields).orEmpty() }
|
||||
val headline = headlineFields(runFields)
|
||||
val evidence = evidenceFields(runFields)
|
||||
val expansion = rememberSectionExpansion(stageKey)
|
||||
|
||||
ModalBottomSheet(
|
||||
onDismissRequest = onDismiss,
|
||||
sheetState = sheetState,
|
||||
dragHandle = { BottomSheetDefaults.DragHandle() },
|
||||
) {
|
||||
Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.TopCenter) {
|
||||
Column(
|
||||
modifier = Modifier
|
||||
.widthIn(max = DETAIL_MAX_WIDTH_DP.dp)
|
||||
.fillMaxWidth()
|
||||
.verticalScroll(rememberScrollState())
|
||||
.padding(horizontal = 16.dp, vertical = 8.dp),
|
||||
verticalArrangement = Arrangement.spacedBy(4.dp),
|
||||
) {
|
||||
Text(
|
||||
GraphSemantics.nodeLabel(stageKey),
|
||||
style = text.screenTitle,
|
||||
modifier = Modifier.semantics { heading() },
|
||||
)
|
||||
StageTypeChip(typeLabel)
|
||||
if (showVisitTabs(runSteps.size)) {
|
||||
PrimaryScrollableTabRow(
|
||||
selectedTabIndex = clampedVisit,
|
||||
edgePadding = 0.dp,
|
||||
modifier = Modifier.fillMaxWidth().padding(top = 8.dp),
|
||||
) {
|
||||
runSteps.forEachIndexed { index, _ ->
|
||||
Tab(
|
||||
selected = index == clampedVisit,
|
||||
onClick = { visitIndex = index },
|
||||
text = { Text("visit ${index + 1}", maxLines = 1) },
|
||||
)
|
||||
}
|
||||
DetailTabBody(wide, modifier) { columnModifier ->
|
||||
Column(
|
||||
modifier = columnModifier
|
||||
.verticalScroll(rememberScrollState())
|
||||
.padding(horizontal = 16.dp, vertical = 8.dp),
|
||||
verticalArrangement = Arrangement.spacedBy(4.dp),
|
||||
) {
|
||||
Text(
|
||||
GraphSemantics.nodeLabel(stageKey),
|
||||
style = text.screenTitle,
|
||||
modifier = Modifier.semantics { heading() },
|
||||
)
|
||||
StageTypeChip(typeLabel)
|
||||
if (showVisitTabs(runSteps.size)) {
|
||||
PrimaryScrollableTabRow(
|
||||
selectedTabIndex = clampedVisit,
|
||||
edgePadding = 0.dp,
|
||||
modifier = Modifier.fillMaxWidth().padding(top = 8.dp),
|
||||
) {
|
||||
runSteps.forEachIndexed { index, _ ->
|
||||
Tab(
|
||||
selected = index == clampedVisit,
|
||||
onClick = { visitIndex = index },
|
||||
text = { Text("visit ${index + 1}", maxLines = 1) },
|
||||
)
|
||||
}
|
||||
}
|
||||
if (definition.isNotEmpty()) {
|
||||
Text("Definition", style = text.sectionHeader, modifier = Modifier.padding(top = 8.dp))
|
||||
}
|
||||
|
||||
// Identity and result: always visible, never behind a collapse, so a
|
||||
// freshly opened pane never reads as empty.
|
||||
headline.forEach { field -> StageFieldRow(field) }
|
||||
if (headline.isEmpty() && selectedStep == null && stage == null && definition.isEmpty()) {
|
||||
Text("No details recorded for this node.", style = text.meta)
|
||||
}
|
||||
|
||||
if (definition.isNotEmpty()) {
|
||||
val key = "definition"
|
||||
SectionHeader(key.capitalized(), expansion.isExpanded(key), { expansion.toggle(key) })
|
||||
if (expansion.isExpanded(key)) {
|
||||
definition.forEach { field -> StageFieldRow(field) }
|
||||
}
|
||||
if (selectedStep != null) {
|
||||
Text("This run", style = text.sectionHeader, modifier = Modifier.padding(top = 8.dp))
|
||||
run.forEach { field -> StageFieldRow(field) }
|
||||
}
|
||||
|
||||
if (selectedStep != null) {
|
||||
val inputFields = runFields.filter { it.label == "Input" }
|
||||
val outputFields = runFields.filter { it.label == "Output" }
|
||||
if (inputFields.isNotEmpty()) {
|
||||
val key = "input"
|
||||
SectionHeader(key.capitalized(), expansion.isExpanded(key), { expansion.toggle(key) })
|
||||
if (expansion.isExpanded(key)) inputFields.forEach { StageFieldRow(it) }
|
||||
}
|
||||
if (outputFields.isNotEmpty()) {
|
||||
val key = "output"
|
||||
SectionHeader(key.capitalized(), expansion.isExpanded(key), { expansion.toggle(key) })
|
||||
if (expansion.isExpanded(key)) outputFields.forEach { StageFieldRow(it) }
|
||||
}
|
||||
val artifactsKey = "artifacts"
|
||||
SectionHeader(
|
||||
artifactsKey.capitalized(),
|
||||
expansion.isExpanded(artifactsKey),
|
||||
{ expansion.toggle(artifactsKey) },
|
||||
)
|
||||
if (expansion.isExpanded(artifactsKey)) {
|
||||
ArtifactsSection(
|
||||
step = selectedStep,
|
||||
configuredServerUrl = configuredServerUrl,
|
||||
fetchArtifactBytes = fetchArtifactBytes,
|
||||
)
|
||||
}
|
||||
if (definition.isEmpty() && selectedStep == null) {
|
||||
Text("No details recorded for this node.", style = text.meta)
|
||||
if (evidence.isNotEmpty()) {
|
||||
val key = "run"
|
||||
SectionHeader(
|
||||
"This run",
|
||||
expansion.isExpanded(key),
|
||||
{ expansion.toggle(key) },
|
||||
)
|
||||
if (expansion.isExpanded(key)) {
|
||||
evidence.forEach { field -> StageFieldRow(field) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** The stage pane hosted directly by the run destination, reading the run detail. */
|
||||
@Composable
|
||||
fun RunStagePane(
|
||||
vm: AppViewModel,
|
||||
runId: Long,
|
||||
stageKey: String,
|
||||
visitIndex: Int,
|
||||
onBack: () -> Unit,
|
||||
wide: Boolean,
|
||||
modifier: Modifier = Modifier,
|
||||
) {
|
||||
val state by vm.runDetail.collectAsStateWithLifecycle()
|
||||
val configuredServerUrl by vm.configuredServerUrl.collectAsStateWithLifecycle()
|
||||
val run = state.data?.takeIf { it.id == runId }
|
||||
val steps = run?.steps.orEmpty()
|
||||
// One aggregation per step-list change; the stage's visits are read from it.
|
||||
val timeline = remember(steps) { runTimeline(steps) }
|
||||
StageDetailPane(
|
||||
stageKey = stageKey,
|
||||
graph = run?.graph ?: Graph(),
|
||||
runSteps = timeline.visitsByStage[stageKey].orEmpty(),
|
||||
initialVisitIndex = visitIndex,
|
||||
configuredServerUrl = configuredServerUrl,
|
||||
fetchArtifactBytes = vm::fetchArtifactBytes,
|
||||
onBack = onBack,
|
||||
wide = wide,
|
||||
modifier = modifier,
|
||||
)
|
||||
}
|
||||
|
||||
/** The stage pane hosted by the pipeline destination; a definition has no run. */
|
||||
@Composable
|
||||
fun PipelineStagePane(
|
||||
vm: AppViewModel,
|
||||
pipelineId: Long,
|
||||
version: Int,
|
||||
stageKey: String,
|
||||
onBack: () -> Unit,
|
||||
wide: Boolean,
|
||||
modifier: Modifier = Modifier,
|
||||
) {
|
||||
val state by vm.pipelineDetail.collectAsStateWithLifecycle()
|
||||
val detail = state.data?.takeIf { it.id == pipelineId && it.version == version }
|
||||
StageDetailPane(
|
||||
stageKey = stageKey,
|
||||
graph = detail?.graph ?: Graph(),
|
||||
onBack = onBack,
|
||||
wide = wide,
|
||||
modifier = modifier,
|
||||
)
|
||||
}
|
||||
|
||||
/** One field as either the shared code card (blocks) or a key/value row. */
|
||||
@Composable
|
||||
internal fun StageFieldRow(field: StageField) {
|
||||
@@ -338,3 +492,7 @@ internal fun StageTypeChip(label: String) {
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/** A section key as its visible title ("definition" → "Definition"). */
|
||||
private fun String.capitalized(): String =
|
||||
replaceFirstChar { if (it.isLowerCase()) it.titlecase() else it.toString() }
|
||||
@@ -33,7 +33,6 @@ import androidx.compose.material3.TopAppBar
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.LaunchedEffect
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableIntStateOf
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.remember
|
||||
import androidx.compose.runtime.saveable.rememberSaveable
|
||||
@@ -57,7 +56,6 @@ import net.awan.pipelines.ui.components.LoadingState
|
||||
import net.awan.pipelines.ui.components.collapsibleSection
|
||||
import net.awan.pipelines.ui.components.pipelineDetailTabs
|
||||
import net.awan.pipelines.ui.components.rememberSectionExpansion
|
||||
import net.awan.pipelines.ui.graph.StageDetailSheet
|
||||
import net.awan.pipelines.ui.graph.StageFieldRow
|
||||
import net.awan.pipelines.ui.graph.WorkflowGraph
|
||||
import net.awan.pipelines.ui.graph.effectiveStageType
|
||||
@@ -72,13 +70,14 @@ fun PipelineDetailScreen(
|
||||
version: Int,
|
||||
onBack: () -> Unit,
|
||||
onOpenRun: (Long) -> Unit,
|
||||
selectedSection: Int,
|
||||
onSelectSection: (Int) -> Unit,
|
||||
onOpenStage: (String) -> Unit,
|
||||
modifier: Modifier = Modifier,
|
||||
wide: Boolean = false,
|
||||
) {
|
||||
val state by vm.pipelineDetail.collectAsStateWithLifecycle()
|
||||
var showStart by remember { mutableStateOf(false) }
|
||||
// Summary is the first/default tab; selection survives config changes.
|
||||
var selectedTab by rememberSaveable { mutableIntStateOf(0) }
|
||||
|
||||
LaunchedEffect(pipelineId, version) { vm.loadPipeline(pipelineId, version) }
|
||||
|
||||
@@ -114,15 +113,19 @@ fun PipelineDetailScreen(
|
||||
detail == null -> LoadingState("Loading pipeline…", Modifier.padding(padding))
|
||||
else -> DetailTabs(
|
||||
tabs = pipelineDetailTabs,
|
||||
selectedIndex = selectedTab,
|
||||
onSelect = { selectedTab = it },
|
||||
selectedIndex = selectedSection,
|
||||
onSelect = onSelectSection,
|
||||
wide = wide,
|
||||
modifier = Modifier.padding(padding),
|
||||
modifier = Modifier.padding(padding).fillMaxSize(),
|
||||
) { tab, contentModifier ->
|
||||
// Only the selected tab's content composes (one scroll container each).
|
||||
// The pager composes only the visible section's content.
|
||||
when (tab.key) {
|
||||
"summary" -> PipelineSummaryTab(detail, wide, contentModifier)
|
||||
"graph" -> PipelineGraphTab(detail, contentModifier)
|
||||
"graph" -> PipelineGraphTab(
|
||||
detail = detail,
|
||||
modifier = contentModifier,
|
||||
onStageTap = onOpenStage,
|
||||
)
|
||||
else -> PipelineSourceTab(detail, contentModifier)
|
||||
}
|
||||
}
|
||||
@@ -203,11 +206,12 @@ private fun PipelineSummaryTab(detail: PipelineDetail, wide: Boolean, modifier:
|
||||
|
||||
/** The graph tab on its own: the full-height panel with its Fit/expand controls. */
|
||||
@Composable
|
||||
private fun PipelineGraphTab(detail: PipelineDetail, modifier: Modifier) {
|
||||
private fun PipelineGraphTab(
|
||||
detail: PipelineDetail,
|
||||
modifier: Modifier,
|
||||
onStageTap: (String) -> Unit,
|
||||
) {
|
||||
val text = pipelinesText()
|
||||
// The stage whose detail sheet is open; survives configuration changes. The
|
||||
// sheet is an overlay on this screen (no navigation route).
|
||||
var selectedStage by rememberSaveable { mutableStateOf<String?>(null) }
|
||||
LazyColumn(
|
||||
modifier = modifier,
|
||||
contentPadding = PaddingValues(vertical = 16.dp),
|
||||
@@ -224,18 +228,11 @@ private fun PipelineGraphTab(detail: PipelineDetail, modifier: Modifier) {
|
||||
WorkflowGraph(
|
||||
graph = detail.graph,
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
onStageTap = { selectedStage = it },
|
||||
onStageTap = onStageTap,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
selectedStage?.let { key ->
|
||||
StageDetailSheet(
|
||||
stageKey = key,
|
||||
graph = detail.graph,
|
||||
onDismiss = { selectedStage = null },
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -8,7 +8,6 @@ import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.lazy.LazyColumn
|
||||
import androidx.compose.foundation.lazy.items
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.automirrored.filled.KeyboardArrowLeft
|
||||
import androidx.compose.material.icons.filled.AccountTree
|
||||
import androidx.compose.material.icons.filled.Refresh
|
||||
import androidx.compose.material.icons.filled.Search
|
||||
@@ -45,7 +44,6 @@ fun PipelineListScreen(
|
||||
onOpen: (id: Long, version: Int) -> Unit,
|
||||
modifier: Modifier = Modifier,
|
||||
selectedId: Long? = null,
|
||||
onTogglePane: (() -> Unit)? = null,
|
||||
) {
|
||||
val state by vm.pipelines.collectAsStateWithLifecycle()
|
||||
var query by remember { mutableStateOf("") }
|
||||
@@ -61,14 +59,6 @@ fun PipelineListScreen(
|
||||
IconButton(onClick = vm::refreshPipelines) {
|
||||
Icon(Icons.Default.Refresh, contentDescription = "Refresh pipelines")
|
||||
}
|
||||
if (onTogglePane != null) {
|
||||
IconButton(onClick = onTogglePane) {
|
||||
Icon(
|
||||
Icons.AutoMirrored.Filled.KeyboardArrowLeft,
|
||||
contentDescription = "Collapse list pane",
|
||||
)
|
||||
}
|
||||
}
|
||||
},
|
||||
)
|
||||
},
|
||||
|
||||
@@ -6,6 +6,7 @@ import androidx.compose.foundation.layout.Arrangement
|
||||
import androidx.compose.foundation.layout.Column
|
||||
import androidx.compose.foundation.layout.PaddingValues
|
||||
import androidx.compose.foundation.layout.Row
|
||||
import androidx.compose.foundation.layout.fillMaxSize
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.layout.size
|
||||
@@ -32,10 +33,8 @@ import androidx.compose.material3.TopAppBar
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.LaunchedEffect
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableIntStateOf
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.remember
|
||||
import androidx.compose.runtime.saveable.rememberSaveable
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
@@ -65,8 +64,10 @@ import net.awan.pipelines.ui.components.runDetailTabs
|
||||
import net.awan.pipelines.ui.components.runStateOf
|
||||
import net.awan.pipelines.ui.displayText
|
||||
import net.awan.pipelines.ui.formatDuration
|
||||
import net.awan.pipelines.ui.graph.StageDetailSheet
|
||||
import net.awan.pipelines.ui.artifactsEmptyMessage
|
||||
import net.awan.pipelines.ui.graph.ArtifactGallery
|
||||
import net.awan.pipelines.ui.graph.WorkflowGraph
|
||||
import net.awan.pipelines.ui.runArtifactGroups
|
||||
import net.awan.pipelines.ui.theme.pipelinesText
|
||||
import net.awan.pipelines.ui.visitCount
|
||||
|
||||
@@ -76,6 +77,9 @@ fun RunDetailScreen(
|
||||
vm: AppViewModel,
|
||||
runId: Long,
|
||||
onBack: () -> Unit,
|
||||
selectedSection: Int,
|
||||
onSelectSection: (Int) -> Unit,
|
||||
onOpenStage: (String, Int) -> Unit,
|
||||
modifier: Modifier = Modifier,
|
||||
wide: Boolean = false,
|
||||
) {
|
||||
@@ -85,9 +89,6 @@ fun RunDetailScreen(
|
||||
var confirmCancel by remember { mutableStateOf(false) }
|
||||
var confirmRetry by remember { mutableStateOf(false) }
|
||||
var actionError by remember { mutableStateOf<String?>(null) }
|
||||
// Selected tab survives recomposition and configuration changes; the first
|
||||
// tab (Summary) is the default.
|
||||
var selectedTab by rememberSaveable { mutableIntStateOf(0) }
|
||||
|
||||
LaunchedEffect(runId) {
|
||||
// Scope evidence to this run: drop the previous run's records, then fetch
|
||||
@@ -145,50 +146,56 @@ fun RunDetailScreen(
|
||||
modifier = Modifier.padding(padding),
|
||||
)
|
||||
run == null -> LoadingState("Loading run…", Modifier.padding(padding))
|
||||
else -> DetailTabs(
|
||||
tabs = runDetailTabs,
|
||||
selectedIndex = selectedTab,
|
||||
onSelect = { selectedTab = it },
|
||||
wide = wide,
|
||||
modifier = Modifier.padding(padding),
|
||||
) { tab, contentModifier ->
|
||||
// Only the selected tab's content composes (one scroll container each).
|
||||
when (tab.key) {
|
||||
"summary" -> RunSummaryTab(run, wide, contentModifier)
|
||||
"graph" -> RunGraphTab(
|
||||
run = run,
|
||||
configuredServerUrl = configuredServerUrl,
|
||||
fetchArtifactBytes = vm::fetchArtifactBytes,
|
||||
modifier = contentModifier,
|
||||
)
|
||||
"input" -> RunFieldSectionsTab(
|
||||
emptyMessage = "No input recorded.",
|
||||
keyPrefix = "input",
|
||||
entries = run.input.orEmpty().toList(),
|
||||
wide = wide,
|
||||
modifier = contentModifier,
|
||||
)
|
||||
"output" -> RunFieldSectionsTab(
|
||||
emptyMessage = "No output recorded.",
|
||||
keyPrefix = "output",
|
||||
entries = run.output.orEmpty().toList(),
|
||||
wide = wide,
|
||||
modifier = contentModifier,
|
||||
)
|
||||
"evidence" -> RunEvidenceTab(
|
||||
evidenceState = evidenceState,
|
||||
steps = run.steps,
|
||||
onLoadEvidence = { vm.loadEvidence(runId) },
|
||||
wide = wide,
|
||||
modifier = contentModifier,
|
||||
)
|
||||
else -> RunTimelineTab(
|
||||
run = run,
|
||||
configuredServerUrl = configuredServerUrl,
|
||||
fetchArtifactBytes = vm::fetchArtifactBytes,
|
||||
wide = wide,
|
||||
modifier = contentModifier,
|
||||
)
|
||||
else -> {
|
||||
DetailTabs(
|
||||
tabs = runDetailTabs,
|
||||
selectedIndex = selectedSection,
|
||||
onSelect = onSelectSection,
|
||||
wide = wide,
|
||||
modifier = Modifier.padding(padding).fillMaxSize(),
|
||||
) { tab, contentModifier ->
|
||||
// The pager composes only the visible section's content.
|
||||
when (tab.key) {
|
||||
"summary" -> RunSummaryTab(
|
||||
run = run,
|
||||
wide = wide,
|
||||
modifier = contentModifier,
|
||||
configuredServerUrl = configuredServerUrl,
|
||||
fetchArtifactBytes = vm::fetchArtifactBytes,
|
||||
)
|
||||
"graph" -> RunGraphTab(
|
||||
run = run,
|
||||
modifier = contentModifier,
|
||||
onStageTap = onOpenStage,
|
||||
)
|
||||
"input" -> RunFieldSectionsTab(
|
||||
emptyMessage = "No input recorded.",
|
||||
keyPrefix = "input",
|
||||
entries = run.input.orEmpty().toList(),
|
||||
wide = wide,
|
||||
modifier = contentModifier,
|
||||
)
|
||||
"output" -> RunFieldSectionsTab(
|
||||
emptyMessage = "No output recorded.",
|
||||
keyPrefix = "output",
|
||||
entries = run.output.orEmpty().toList(),
|
||||
wide = wide,
|
||||
modifier = contentModifier,
|
||||
)
|
||||
"evidence" -> RunEvidenceTab(
|
||||
evidenceState = evidenceState,
|
||||
steps = run.steps,
|
||||
onLoadEvidence = { vm.loadEvidence(runId) },
|
||||
wide = wide,
|
||||
modifier = contentModifier,
|
||||
)
|
||||
else -> RunTimelineTab(
|
||||
run = run,
|
||||
wide = wide,
|
||||
modifier = contentModifier,
|
||||
onStageTap = onOpenStage,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -260,9 +267,17 @@ private fun ConfirmDialog(
|
||||
* the failure diagnostic.
|
||||
*/
|
||||
@Composable
|
||||
private fun RunSummaryTab(run: RunDetail, wide: Boolean, modifier: Modifier) {
|
||||
private fun RunSummaryTab(
|
||||
run: RunDetail,
|
||||
wide: Boolean,
|
||||
modifier: Modifier,
|
||||
configuredServerUrl: String,
|
||||
fetchArtifactBytes: suspend (String) -> ByteArray?,
|
||||
) {
|
||||
val text = pipelinesText()
|
||||
val state = runStateOf(run.status)
|
||||
// Aggregated once per step-list change, never per recomposition.
|
||||
val artifactGroups = remember(run.steps) { runArtifactGroups(run.steps) }
|
||||
DetailTabBody(wide, modifier) { columnModifier ->
|
||||
LazyColumn(
|
||||
modifier = columnModifier,
|
||||
@@ -303,6 +318,23 @@ private fun RunSummaryTab(run: RunDetail, wide: Boolean, modifier: Modifier) {
|
||||
CodeBlock("Diagnostic", run.diagnostic, Modifier.padding(top = 8.dp))
|
||||
}
|
||||
}
|
||||
item(key = "run-artifacts") {
|
||||
Column(
|
||||
modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 8.dp),
|
||||
verticalArrangement = Arrangement.spacedBy(8.dp),
|
||||
) {
|
||||
Text("Artifacts", style = text.sectionHeader)
|
||||
if (artifactGroups.isEmpty()) {
|
||||
Text(artifactsEmptyMessage(run.executing), style = text.meta)
|
||||
} else {
|
||||
ArtifactGallery(
|
||||
groups = artifactGroups,
|
||||
configuredServerUrl = configuredServerUrl,
|
||||
fetchArtifactBytes = fetchArtifactBytes,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -315,17 +347,14 @@ private fun RunSummaryTab(run: RunDetail, wide: Boolean, modifier: Modifier) {
|
||||
@Composable
|
||||
private fun RunGraphTab(
|
||||
run: RunDetail,
|
||||
configuredServerUrl: String,
|
||||
fetchArtifactBytes: suspend (String) -> ByteArray?,
|
||||
modifier: Modifier,
|
||||
onStageTap: (String, Int) -> Unit,
|
||||
) {
|
||||
val text = pipelinesText()
|
||||
val runState = remember(run.id, run.steps) { RunGraphState.from(run) }
|
||||
// Grouped once per step-list change; the sheet opened from the graph starts on
|
||||
// the most recent visit of the tapped stage.
|
||||
val timeline = remember(run.steps) { runTimeline(run.steps) }
|
||||
// The stage whose detail sheet is open; the sheet overlays this screen.
|
||||
var selectedStage by rememberSaveable { mutableStateOf<String?>(null) }
|
||||
LazyColumn(
|
||||
modifier = modifier,
|
||||
contentPadding = PaddingValues(vertical = 16.dp),
|
||||
@@ -347,25 +376,15 @@ private fun RunGraphTab(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
runState = runState,
|
||||
selectedStage = runState.currentStage,
|
||||
onStageTap = { selectedStage = it },
|
||||
onStageTap = { key ->
|
||||
val visits = timeline.visitsByStage[key].orEmpty()
|
||||
onStageTap(key, (visits.size - 1).coerceAtLeast(0))
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
selectedStage?.let { key ->
|
||||
val visits = timeline.visitsByStage[key].orEmpty()
|
||||
StageDetailSheet(
|
||||
stageKey = key,
|
||||
graph = run.graph,
|
||||
// Every recorded visit for the stage, opening on the most recent one.
|
||||
runSteps = visits,
|
||||
initialVisitIndex = (visits.size - 1).coerceAtLeast(0),
|
||||
configuredServerUrl = configuredServerUrl,
|
||||
fetchArtifactBytes = fetchArtifactBytes,
|
||||
onDismiss = { selectedStage = null },
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -529,7 +548,7 @@ internal fun evidenceSectionTitle(record: SessionEvidence, step: RunStep?): Stri
|
||||
/**
|
||||
* The Timeline tab: one compact line per recorded visit (stage name, visit
|
||||
* number, outcome chip and duration plus a brief description) and nothing else.
|
||||
* The heavy per-step evidence lives only in the [StageDetailSheet] opened by
|
||||
* The heavy per-step evidence lives only in the stage pane opened by
|
||||
* tapping an entry. The steps are grouped once per step-list change, not per
|
||||
* recomposition, and rendered in this single LazyColumn.
|
||||
*/
|
||||
@@ -537,16 +556,13 @@ internal fun evidenceSectionTitle(record: SessionEvidence, step: RunStep?): Stri
|
||||
@Composable
|
||||
private fun RunTimelineTab(
|
||||
run: RunDetail,
|
||||
configuredServerUrl: String,
|
||||
fetchArtifactBytes: suspend (String) -> ByteArray?,
|
||||
wide: Boolean,
|
||||
modifier: Modifier,
|
||||
onStageTap: (String, Int) -> Unit,
|
||||
) {
|
||||
val text = pipelinesText()
|
||||
// Grouped once per step-list change, not per recomposition.
|
||||
val timeline = remember(run.steps) { runTimeline(run.steps) }
|
||||
var sheetStage by rememberSaveable { mutableStateOf<String?>(null) }
|
||||
var sheetVisit by rememberSaveable { mutableIntStateOf(0) }
|
||||
DetailTabBody(wide, modifier) { columnModifier ->
|
||||
LazyColumn(
|
||||
modifier = columnModifier,
|
||||
@@ -566,26 +582,13 @@ private fun RunTimelineTab(
|
||||
key = { "timeline-${it.stageKey}-${it.step.sequence}" },
|
||||
) { entry ->
|
||||
TimelineRow(entry) {
|
||||
sheetStage = entry.stageKey
|
||||
sheetVisit = entry.visitIndex
|
||||
onStageTap(entry.stageKey, entry.visitIndex)
|
||||
}
|
||||
HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
sheetStage?.let { key ->
|
||||
StageDetailSheet(
|
||||
stageKey = key,
|
||||
graph = run.graph,
|
||||
runSteps = timeline.visitsByStage[key].orEmpty(),
|
||||
// Open on the exact visit that was tapped.
|
||||
initialVisitIndex = sheetVisit,
|
||||
configuredServerUrl = configuredServerUrl,
|
||||
fetchArtifactBytes = fetchArtifactBytes,
|
||||
onDismiss = { sheetStage = null },
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -16,7 +16,6 @@ import androidx.compose.foundation.lazy.LazyColumn
|
||||
import androidx.compose.foundation.lazy.items
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.automirrored.filled.KeyboardArrowLeft
|
||||
import androidx.compose.material.icons.filled.Refresh
|
||||
import androidx.compose.material3.Card
|
||||
import androidx.compose.material3.CircularProgressIndicator
|
||||
@@ -66,7 +65,6 @@ fun RunHistoryScreen(
|
||||
modifier: Modifier = Modifier,
|
||||
filterPipelineId: Long? = null,
|
||||
selectedRunId: Long? = null,
|
||||
onTogglePane: (() -> Unit)? = null,
|
||||
) {
|
||||
val state by vm.runs.collectAsStateWithLifecycle()
|
||||
LaunchedEffect(Unit) { vm.refreshRuns() }
|
||||
@@ -80,14 +78,6 @@ fun RunHistoryScreen(
|
||||
IconButton(onClick = vm::refreshRuns) {
|
||||
Icon(Icons.Default.Refresh, contentDescription = "Refresh runs")
|
||||
}
|
||||
if (onTogglePane != null) {
|
||||
IconButton(onClick = onTogglePane) {
|
||||
Icon(
|
||||
Icons.AutoMirrored.Filled.KeyboardArrowLeft,
|
||||
contentDescription = "Collapse list pane",
|
||||
)
|
||||
}
|
||||
}
|
||||
},
|
||||
)
|
||||
},
|
||||
|
||||
@@ -0,0 +1,98 @@
|
||||
package net.awan.pipelines.ui
|
||||
|
||||
import net.awan.pipelines.data.protocol.ControlEvidence
|
||||
import net.awan.pipelines.data.protocol.RunStep
|
||||
import net.awan.pipelines.data.protocol.StageArtifact
|
||||
import net.awan.pipelines.ui.screens.runTimeline
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
|
||||
class ArtifactGroupsTest {
|
||||
|
||||
private fun step(
|
||||
stage: String,
|
||||
sequence: Int,
|
||||
visit: Int = 0,
|
||||
artifacts: List<StageArtifact>? = null,
|
||||
) = RunStep(
|
||||
sequence = sequence,
|
||||
stage = stage,
|
||||
control = ControlEvidence(visit = visit),
|
||||
artifacts = artifacts,
|
||||
)
|
||||
|
||||
private fun artifact(name: String, url: String = "/artifacts/$name") =
|
||||
StageArtifact(name = name, url = url)
|
||||
|
||||
@Test
|
||||
fun groupsByStageAndVisitInStableOrder() {
|
||||
val steps = listOf(
|
||||
step("planner", sequence = 1, visit = 1, artifacts = listOf(artifact("plan.md"))),
|
||||
step("planner", sequence = 2, visit = 2, artifacts = listOf(artifact("plan-2.md"))),
|
||||
step("build", sequence = 3, visit = 1, artifacts = listOf(artifact("app.apk"))),
|
||||
)
|
||||
val groups = runArtifactGroups(steps)
|
||||
assertEquals(listOf("planner" to 1, "planner" to 2, "build" to 1), groups.map { it.stageKey to it.visit })
|
||||
assertEquals("plan.md", groups[0].artifacts.single().name)
|
||||
assertEquals("plan-2.md", groups[1].artifacts.single().name)
|
||||
assertEquals("app.apk", groups[2].artifacts.single().name)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun duplicateNamesAreKeptNotDeduped() {
|
||||
val steps = listOf(
|
||||
step(
|
||||
"planner",
|
||||
sequence = 1,
|
||||
visit = 1,
|
||||
artifacts = listOf(artifact("shot.png", "/a"), artifact("shot.png", "/b")),
|
||||
),
|
||||
)
|
||||
val group = runArtifactGroups(steps).single()
|
||||
assertEquals(2, group.artifacts.size)
|
||||
assertEquals(listOf("/a", "/b"), group.artifacts.map { it.url })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun visitsWithoutArtifactsProduceNoGroup() {
|
||||
// An explicitly empty capture and a stage the run never recorded artifacts
|
||||
// for both yield nothing.
|
||||
val steps = listOf(
|
||||
step("planner", sequence = 1, visit = 1, artifacts = emptyList()),
|
||||
step("planner", sequence = 2, visit = 2, artifacts = null),
|
||||
step("build", sequence = 3, visit = 1, artifacts = listOf(artifact("app.apk"))),
|
||||
)
|
||||
val groups = runArtifactGroups(steps)
|
||||
assertEquals(listOf("build" to 1), groups.map { it.stageKey to it.visit })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun emptyRunProducesNoGroups() {
|
||||
assertEquals(emptyList<ArtifactGroup>(), runArtifactGroups(emptyList()))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun visitNumbersMatchRunTimeline() {
|
||||
val steps = listOf(
|
||||
step("planner", sequence = 1, visit = 0, artifacts = listOf(artifact("a"))),
|
||||
step("planner", sequence = 2, visit = 0, artifacts = listOf(artifact("b"))),
|
||||
)
|
||||
val groups = runArtifactGroups(steps)
|
||||
val timelineVisits = runTimeline(steps).visitsByStage.getValue("planner")
|
||||
assertEquals(timelineVisits.size, groups.size)
|
||||
groups.forEachIndexed { index, group ->
|
||||
// The display visit number is the same as the timeline's position+1
|
||||
// when the step carries no recorded control visit.
|
||||
assertEquals(index + 1, group.visit)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun emptyStateDistinguishesRunningFromFinished() {
|
||||
assertEquals("No artifacts recorded for this run.", artifactsEmptyMessage(executing = false))
|
||||
val pending = artifactsEmptyMessage(executing = true)
|
||||
assertTrue(pending.startsWith("Artifacts · "))
|
||||
assertTrue(pending.contains(ARTIFACT_CAPTURE_PENDING))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
package net.awan.pipelines.ui
|
||||
|
||||
import java.io.File
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
|
||||
/**
|
||||
* Guards that the collapse-based master/detail interaction is gone for good: no
|
||||
* source file may mention the removed composables, callbacks, constants or
|
||||
* content descriptions. The scan is source text, so it is fast and needs no
|
||||
* device.
|
||||
*/
|
||||
class CollapseRemovalTest {
|
||||
|
||||
/** Identifiers/labels that existed only for the removed collapse behaviour. */
|
||||
private val banned = listOf(
|
||||
// List-pane collapse.
|
||||
"CollapsedListPane",
|
||||
"onTogglePane",
|
||||
"paneExpanded",
|
||||
"COLLAPSED_LIST_PANE_WIDTH",
|
||||
"LIST_PANE_WIDTH",
|
||||
"Collapse list pane",
|
||||
// Observed-side rail collapse.
|
||||
"RailToggle",
|
||||
"railWidthDp",
|
||||
"COLLAPSED_RAIL_WIDTH_DP",
|
||||
"Collapse tabs",
|
||||
)
|
||||
|
||||
@Test
|
||||
fun noCollapseBehaviourRemainsInSources() {
|
||||
val root = sourceRoot()
|
||||
val hits = ArrayList<String>()
|
||||
root.walkTopDown()
|
||||
.filter { it.isFile && it.extension == "kt" }
|
||||
.forEach { file ->
|
||||
file.useLines { lines ->
|
||||
lines.forEachIndexed { index, line ->
|
||||
banned.firstOrNull { line.contains(it) }?.let { token ->
|
||||
hits += "${file.relativeTo(root)}:${index + 1}: $token"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
assertTrue("removed collapse identifiers remain: $hits", hits.isEmpty())
|
||||
}
|
||||
|
||||
private fun sourceRoot(): File {
|
||||
val candidates = listOf("src/main/java", "app/src/main/java")
|
||||
.map { File(System.getProperty("user.dir"), it) }
|
||||
val root = candidates.firstOrNull { it.isDirectory }
|
||||
assertTrue("could not locate src/main/java from ${System.getProperty("user.dir")}: $candidates", root != null)
|
||||
// Fail loudly if the scan found nothing, so the guard can never pass
|
||||
// vacuously.
|
||||
assertTrue("no Kotlin sources found under $root", root!!.walkTopDown().any { it.extension == "kt" })
|
||||
return root
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,129 @@
|
||||
package net.awan.pipelines.ui
|
||||
|
||||
import androidx.compose.runtime.saveable.SaverScope
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
|
||||
class PaneStateTest {
|
||||
|
||||
@Test
|
||||
fun backFromListLeavesTheApp() {
|
||||
assertEquals(BackResult.Exit, backStep(PaneSelection()))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun backInsideDetailReturnsToTheListAndClearsTheItem() {
|
||||
val detail = PaneSelection(MasterPane.Detail, itemId = 7L, itemVersion = 3, sectionIndex = 2)
|
||||
val result = backStep(detail) as BackResult.Show
|
||||
// One pane level only: sections are navigated by their own tab row, never
|
||||
// by Back, so the section index is not touched by a Back step.
|
||||
assertEquals(MasterPane.List, result.selection.pane)
|
||||
assertEquals(0L, result.selection.itemId)
|
||||
assertEquals(0, result.selection.depth)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun backInsideStageReturnsToTheDetailClearingTheStage() {
|
||||
val stage = PaneSelection(
|
||||
pane = MasterPane.Stage,
|
||||
itemId = 7L,
|
||||
itemVersion = 3,
|
||||
sectionIndex = 1,
|
||||
stageKey = "planner",
|
||||
stageVisit = 2,
|
||||
)
|
||||
val result = backStep(stage) as BackResult.Show
|
||||
// Exactly one level: stage -> detail, keeping the item and section, and
|
||||
// clearing the stage selection.
|
||||
assertEquals(MasterPane.Detail, result.selection.pane)
|
||||
assertEquals(7L, result.selection.itemId)
|
||||
assertEquals(1, result.selection.sectionIndex)
|
||||
assertEquals(null, result.selection.stageKey)
|
||||
assertEquals(0, result.selection.stageVisit)
|
||||
assertEquals(1, result.selection.depth)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun depthIsBoundedByTheDeclaredMaximum() {
|
||||
assertEquals(0, PaneSelection(MasterPane.List).depth)
|
||||
assertEquals(1, PaneSelection(MasterPane.Detail, itemId = 1L).depth)
|
||||
assertEquals(2, PaneSelection(MasterPane.Stage, itemId = 1L, stageKey = "s").depth)
|
||||
// Every pane's depth is within the bound; the stack can never grow deeper.
|
||||
MasterPane.entries.forEach { pane ->
|
||||
assertTrue(PaneSelection(pane = pane).depth <= MAX_PANE_DEPTH)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun popToClosesEveryPaneToTheRight() {
|
||||
val stage = PaneSelection(
|
||||
pane = MasterPane.Stage,
|
||||
itemId = 9L,
|
||||
itemVersion = 2,
|
||||
sectionIndex = 1,
|
||||
stageKey = "s",
|
||||
stageVisit = 3,
|
||||
)
|
||||
// Level 0 (list): everything closes.
|
||||
assertEquals(PaneSelection(), popTo(stage, 0))
|
||||
// Level 1 (detail): only the stage closes, the item is kept.
|
||||
val detail = popTo(stage, 1)
|
||||
assertEquals(MasterPane.Detail, detail.pane)
|
||||
assertEquals(9L, detail.itemId)
|
||||
assertEquals(2, detail.itemVersion)
|
||||
assertEquals(1, detail.sectionIndex)
|
||||
assertEquals(null, detail.stageKey)
|
||||
// A level at or beyond the current depth is a no-op.
|
||||
assertEquals(stage, popTo(stage, 2))
|
||||
assertEquals(stage, popTo(stage, 5))
|
||||
assertEquals(PaneSelection(MasterPane.Detail, 4L), popTo(PaneSelection(MasterPane.Detail, 4L), 3))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun savedStateRoundTripsThroughTheSaver() {
|
||||
val scope = SaverScope { true }
|
||||
val cases = listOf(
|
||||
PaneSelection(),
|
||||
PaneSelection(MasterPane.Detail, itemId = 42L, itemVersion = 5, sectionIndex = 3),
|
||||
PaneSelection(MasterPane.Detail, itemId = 1L, itemVersion = 0, sectionIndex = 0),
|
||||
PaneSelection(
|
||||
pane = MasterPane.Stage,
|
||||
itemId = 8L,
|
||||
itemVersion = 2,
|
||||
sectionIndex = 4,
|
||||
stageKey = "planner",
|
||||
stageVisit = 3,
|
||||
),
|
||||
)
|
||||
cases.forEach { selection ->
|
||||
val saved = with(PaneSelectionSaver) { scope.save(selection) }
|
||||
assertEquals(selection, PaneSelectionSaver.restore(saved!!))
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun encodedPayloadIsPrimitivesOnly() {
|
||||
// Process-death restoration stays small: only Strings, ints and a long,
|
||||
// with a null stage key encoded as an empty string.
|
||||
val encoded = encodePaneSelection(
|
||||
PaneSelection(
|
||||
pane = MasterPane.Stage,
|
||||
itemId = 9L,
|
||||
itemVersion = 2,
|
||||
sectionIndex = 1,
|
||||
stageKey = "planner",
|
||||
stageVisit = 4,
|
||||
),
|
||||
)
|
||||
assertEquals(listOf("Stage", 9L, 2, 1, "planner", 4), encoded)
|
||||
assertEquals(
|
||||
PaneSelection(MasterPane.Stage, 9L, 2, 1, "planner", 4),
|
||||
decodePaneSelection(encoded),
|
||||
)
|
||||
assertEquals(
|
||||
listOf("Detail", 9L, 2, 1, "", 0),
|
||||
encodePaneSelection(PaneSelection(MasterPane.Detail, 9L, 2, 1)),
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -16,12 +16,11 @@ class PipelinesNavTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
fun detailRoutesKeepTheirListDestinationSelected() {
|
||||
// A pipeline detail belongs to Pipelines, a run detail to Runs.
|
||||
assertTrue(destinationSelected("pipeline/1/2", "pipelines"))
|
||||
assertFalse(destinationSelected("pipeline/1/2", "runs"))
|
||||
assertTrue(destinationSelected("run/5", "runs"))
|
||||
assertFalse(destinationSelected("run/5", "pipelines"))
|
||||
fun detailRoutesAreNoLongerSeparateDestinations() {
|
||||
// Detail panes are saved state inside a destination, not routes, so a
|
||||
// stale route string selects nothing.
|
||||
assertFalse(destinationSelected("pipeline/1/2", "pipelines"))
|
||||
assertFalse(destinationSelected("run/5", "runs"))
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
@@ -37,11 +37,6 @@ class DetailTabsTest {
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun collapsedRailIsNarrowerThanExpanded() {
|
||||
assertTrue(railWidthDp(false) < railWidthDp(true))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun clampTabIndexKeepsAValidSelection() {
|
||||
assertEquals(0, clampTabIndex(0, 6))
|
||||
|
||||
@@ -0,0 +1,48 @@
|
||||
package net.awan.pipelines.ui.components
|
||||
|
||||
import androidx.compose.ui.unit.dp
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
|
||||
class SlidingPaneStackTest {
|
||||
|
||||
@Test
|
||||
fun peekIsAtLeastTheNamedMinimum() {
|
||||
// The named token (56dp) wins over a smaller platform minimum.
|
||||
assertEquals(56.dp, peekWidthDp(minimumInteractive = 48.dp))
|
||||
assertEquals(56.dp, peekWidthDp(minimumInteractive = 40.dp))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun peekWidensSoTheStripIsStillTappableAfterTheGestureInset() {
|
||||
// The left gesture inset eats 30dp; the visible peek grows so the
|
||||
// tappable strip (peek - inset) is still the minimum interactive size.
|
||||
val peek = peekWidthDp(minimumInteractive = 48.dp, startInset = 30.dp)
|
||||
assertEquals(78.dp, peek)
|
||||
assertTrue(peek - 30.dp >= 48.dp)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun peekWithoutInsetStaysTheNamedToken() {
|
||||
assertEquals(56.dp, peekWidthDp(minimumInteractive = 48.dp, startInset = 0.dp))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun paneOffsetIsOnePeekPerLevel() {
|
||||
// Each open pane sits one more peek to the right, so the pane below keeps
|
||||
// exactly its own peek visible.
|
||||
assertEquals(0.dp, paneOffsetDp(level = 0, peek = 56.dp))
|
||||
assertEquals(56.dp, paneOffsetDp(level = 1, peek = 56.dp))
|
||||
assertEquals(112.dp, paneOffsetDp(level = 2, peek = 56.dp))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun paneWidthIsTheHostLessItsPeeks() {
|
||||
assertEquals(411.dp, paneWidthDp(hostWidth = 411.dp, level = 0, peek = 56.dp))
|
||||
assertEquals(355.dp, paneWidthDp(hostWidth = 411.dp, level = 1, peek = 56.dp))
|
||||
assertEquals(299.dp, paneWidthDp(hostWidth = 411.dp, level = 2, peek = 56.dp))
|
||||
// Never negative when the host is narrower than the stacked peeks.
|
||||
assertEquals(0.dp, paneWidthDp(hostWidth = 100.dp, level = 2, peek = 56.dp))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
package net.awan.pipelines.ui.graph
|
||||
|
||||
import androidx.compose.ui.unit.dp
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
|
||||
class ArtifactGalleryTest {
|
||||
|
||||
private val spacing = 8.dp
|
||||
private val preferred = 96.dp
|
||||
|
||||
@Test
|
||||
fun narrowWidthShrinksTilesSoTheRowNeverOverflows() {
|
||||
// A depth-2 phone stage pane is ~360dp less two 56dp peeks and the 16dp
|
||||
// side paddings ≈216dp; three preferred 96dp tiles would overflow, so the
|
||||
// tile shrinks to the widest that fits.
|
||||
val tile = artifactTileDp(availableWidth = 216.dp, columns = 3, spacing = spacing, preferred = preferred)
|
||||
assertEquals((216f - 2 * 8f) / 3f, tile.value, 0.001f)
|
||||
assertTrue(tile < preferred)
|
||||
assertTrue(tile.value * 3 + 2 * 8f <= 216f)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun widthThatFitsThreePreferredTilesKeepsThePreferredTile() {
|
||||
// 328dp fits 3x96 + 2x8 with room to spare, so tiles stay compact and the
|
||||
// row does not overflow.
|
||||
val tile = artifactTileDp(availableWidth = 328.dp, columns = 3, spacing = spacing, preferred = preferred)
|
||||
assertEquals(preferred, tile)
|
||||
assertTrue(tile.value * 3 + 2 * 8f <= 328f)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun wideWidthKeepsThePreferredCompactTile() {
|
||||
val tile = artifactTileDp(availableWidth = 1200.dp, columns = 3, spacing = spacing, preferred = preferred)
|
||||
assertEquals(preferred, tile)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun exactFitKeepsThePreferredTile() {
|
||||
val available = preferred * 3 + spacing * 2
|
||||
val tile = artifactTileDp(availableWidth = available, columns = 3, spacing = spacing, preferred = preferred)
|
||||
assertEquals(preferred, tile)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun degenerateInputsReturnValidTiles() {
|
||||
// A zero/negative column count or a host narrower than the gaps never
|
||||
// yields a negative tile.
|
||||
assertEquals(preferred, artifactTileDp(availableWidth = 300.dp, columns = 0, spacing = spacing, preferred = preferred))
|
||||
assertEquals(0.dp, artifactTileDp(availableWidth = 4.dp, columns = 3, spacing = spacing, preferred = preferred))
|
||||
}
|
||||
}
|
||||
@@ -135,4 +135,32 @@ class StageDetailSheetTest {
|
||||
assertEquals(listOf("Incoming routes"), incoming.map { it.label })
|
||||
assertTrue(incoming.single().value.contains("a · success → SUCCESS"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun headlineFieldsAreTheAlwaysVisibleIdentityAndResult() {
|
||||
val step = RunStep(
|
||||
status = "succeeded",
|
||||
outcome = "success",
|
||||
target = "cleanup",
|
||||
diagnostic = "why",
|
||||
transcript = "said something",
|
||||
input = mapOf("prompt" to JsonPrimitive("do it")),
|
||||
output = mapOf("result" to JsonPrimitive("done")),
|
||||
control = ControlEvidence(visit = 2, maxVisits = 4, modelTarget = "gpt"),
|
||||
startedAt = "2026-01-01T00:00:00Z",
|
||||
finishedAt = "2026-01-01T00:00:05Z",
|
||||
)
|
||||
val fields = runStepFields(step)
|
||||
val headline = headlineFields(fields).map { it.label }
|
||||
// Exactly the identity/result facts, visible without expanding anything.
|
||||
assertEquals(listOf("Status", "Outcome", "Duration", "Visit", "Model target", "Target"), headline)
|
||||
// None of the collapsible evidence leaks into the headline.
|
||||
assertTrue(headline.none { it == "Diagnostic" || it == "Transcript" || it == "Input" || it == "Output" })
|
||||
// And the headline facts are not repeated in the evidence section.
|
||||
val evidence = evidenceFields(fields).map { it.label }
|
||||
assertTrue(evidence.none { it in headline })
|
||||
assertTrue(evidence.containsAll(listOf("Diagnostic", "Transcript")))
|
||||
// Input/output are surfaced as their own sections, not the evidence block.
|
||||
assertTrue(evidence.none { it == "Input" || it == "Output" })
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user