Keep track of collapsed steps and avoid expanding them automatically

src/main/frontend/pipeline-console-view/pipeline-console/main/hooks/use-steps-poller.spec.ts

@@ -39,6 +39,7 @@ vi.mock("../PipelineConsoleModel.tsx", async () => ({
     startByte: 0,
     endByte: 100,
   }),
+  POLL_INTERVAL: 50,
 }));
 
 beforeEach(() => {
@@ -81,6 +82,38 @@ it("selects the step from URL on initial load", async () => {
   unmount();
 });
 
+it("selected steps can be collapsed and remain collapsed", async () => {
+  window.history.pushState({}, "", "/?selected-node=step-1&start-byte=0");
+
+  let currentSteps = [
+    { id: "step-1", title: "Step 1", stageId: "stage-1", state: "running" },
+    { id: "step-2", title: "Step 2", stageId: "stage-1", state: "queued" },
+  ];
+  (model.getRunSteps as Mock).mockResolvedValue({ steps: currentSteps });
+
+  const props = { currentRunPath: "/run/1" };
+  const { result, unmount } = renderHook(() => useStepsPoller(props));
+  await waitFor(() => expect(result.current.expandedSteps).toContain("step-1"));
+
+  expect(result.current.expandedSteps).toContain("step-1");
+  act(() => result.current.onStepToggle("step-1"));
+  expect(result.current.expandedSteps).not.toContain("step-1");
+
+  // Simulate step-1 finishing and step-2 becoming active
+  currentSteps = [
+    { id: "step-1", title: "Step 1", stageId: "stage-1", state: "success" },
+    { id: "step-2", title: "Step 2", stageId: "stage-1", state: "running" },
+  ];
+  (model.getRunSteps as Mock).mockResolvedValue({ steps: currentSteps });
+
+  await waitFor(() =>
+    expect(result.current.openStageSteps).to.deep.equal(currentSteps),
+  );
+  expect(result.current.expandedSteps).not.toContain("step-1");
+
+  unmount();
+});
+
 it("switches to next stage when current one finishes", async () => {
   let currentSteps = [
     { id: "s1", title: "Step 1", stageId: "stage-1", state: "running" },

src/main/frontend/pipeline-console-view/pipeline-console/main/hooks/use-steps-poller.ts

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 
 import useRunPoller from "../../../../common/tree-api.ts";
 import {
@@ -25,6 +25,7 @@ export function useStepsPoller(props: RunPollerProps) {
     new Map<string, StepLogBufferInfo>(),
   );
   const [userManuallySetNode, setUserManuallySetNode] = useState(false);
+  const collapsedSteps = useRef(new Set<string>());
 
   const updateStepConsoleOffset = useCallback(
     async (stepId: string, forceUpdate: boolean, startByte: number) => {
@@ -61,6 +62,7 @@ export function useStepsPoller(props: RunPollerProps) {
       if (!selected) {
         return false;
       }
+      if (collapsedSteps.current.has(selected)) return true;
 
       setUserManuallySetNode(true);
 
@@ -82,7 +84,7 @@ export function useStepsPoller(props: RunPollerProps) {
       setExpandedSteps(expanded);
       return true;
     },
-    [updateStepConsoleOffset],
+    [updateStepConsoleOffset, collapsedSteps],
   );
 
   const getDefaultSelectedStep = (steps: StepInfo[]) => {
@@ -175,26 +177,26 @@ export function useStepsPoller(props: RunPollerProps) {
 
       const stepsForStage = steps.filter((step) => step.stageId === nodeId);
       const lastStep = stepsForStage[stepsForStage.length - 1];
-      const newlyExpandedSteps = lastStep ? [lastStep.id] : [];
 
       history.replaceState({}, "", `?selected-node=` + nodeId);
 
       setOpenStage(nodeId);
-      setExpandedSteps((prev) => [...prev, ...newlyExpandedSteps]);
-
-      if (lastStep) {
+      if (lastStep && !collapsedSteps.current.has(lastStep.id)) {
+        setExpandedSteps((prev) => [...prev, lastStep.id]);
         updateStepConsoleOffset(lastStep.id, false, 0 - LOG_FETCH_SIZE);
       }
     },
-    [openStage, steps, updateStepConsoleOffset],
+    [openStage, steps, updateStepConsoleOffset, collapsedSteps],
   );
 
   const onStepToggle = (nodeId: string) => {
     setUserManuallySetNode(true);
     if (!expandedSteps.includes(nodeId)) {
+      collapsedSteps.current.delete(nodeId);
       setExpandedSteps((prev) => [...prev, nodeId]);
       updateStepConsoleOffset(nodeId, false, 0 - LOG_FETCH_SIZE);
     } else {
+      collapsedSteps.current.add(nodeId);
       setExpandedSteps((prev) => prev.filter((id) => id !== nodeId));
     }
   };