Skip to content

Commit ad085e9

Browse files
yangzhang75claude
andauthored
fix(workspace, workflow-form): show the step the shared selection already holds (apache#9408)
### What changes were proposed in this PR? Closes apache#9400. A workflow's two views share one selection: it lives in the root-provided `JointGraphWrapper`, which the switch between the canvas and the Form View hands over rather than rebuilds. Nothing is lost in the switch, but everything that shows the selection followed only the highlight streams and never read it when it mounted. The event that made the selection had already happened, so the view arriving at it waited for an event that never came: the panel showed nothing, and the step was drawn as not selected. Clicking that step did not help, since the wrapper treats an already-highlighted element as a no-op and emits nothing; it took clicking a *different* step to bring the panel back. Each of the three now reads the selection it mounts into, then follows the changes as before: - `PropertyEditorComponent` (the canvas's panel and every host of it, so not specific to the Form View, to any operator type, or to operators as opposed to ports): the body of the highlight subscription becomes `showHighlighted()`, the same decision as before (one operator, one port, or nothing) with the `syncTexeraGraph` guard that the stream applied as a `filter` now inside it, so it is applied once on both paths. `registerHighlightEventsHandler()` calls it before subscribing, and only when something is highlighted: the no-frame branch is for a selection being dropped (it clears the editing marker on the shared awareness channel and resizes the docked panel to its empty content), which a fresh mount must not do. It is also called after the toolbar's choosing toggle has replayed its value, so the frame it builds carries `choosing` from the start instead of being torn down and rebuilt by the replay inside the page's first change-detection pass. Not `startWith` on the stream: its initial emission is unconditional, which is exactly the empty-branch-at-mount this avoids. - `WorkflowEditorComponent`: the ring. The paper is new on every switch, and the highlighter was applied only from the stream, so the arriving view would have shown its panel for a step drawn as not selected. The handler now rings the operators and comment boxes the wrapper already holds, then follows the streams; the `findViewByModel` guard the unhighlight branch already had is shared with it. - `WorkflowFormComponent`: one call to the `syncSelectionFromHighlight()` it already has, in `ngOnInit` after it subscribes, so the form's step panel opens on the selection it arrives with. The template note that justified `[hidden]` over `*ngIf` by the panel having "no initial pull" is reworded to the reason that still holds. No change to who owns the selection, to what a click does, or to the canvas's own behaviour when it is the only view open: with nothing selected, nothing is read, and both panels mount empty exactly as before. The wrapper's no-op for an already-highlighted element is deliberately untouched (it is what keeps a shift-selection stable); it simply stops mattering, because the arriving view already shows that step. #### Video **Before** https://github.com/user-attachments/assets/e00affd4-46aa-4691-acc4-5d33060da766 **After** https://github.com/user-attachments/assets/f50674e4-b0fd-4941-bcca-860d1aa61abe ### Any related issues, documentation, discussions? Closes apache#9400. Part of the Form View (apache#8011). Related to apache#8846, which touches `workflow-form.component.ts` elsewhere and does not read the selection on mount: its `frameWrites` guard compares `selectedOperatorId`, which only `syncSelectionFromHighlight()` sets, so on arriving in the Form View with a step selected that guard saw `undefined` and the form wrote the declared parameters even while the live panel showed that step. With this change `selectedOperatorId` is set on arrival and the guard holds. The two do not overlap in code; whichever lands second rebases. ### How was this PR tested? - `property-editor.component.spec.ts`: a panel mounting into an existing selection shows that operator; mounting into no selection leaves the panel alone and mounting into two shows no frame (the two-operator selection is made explicit with `setMultiSelectMode(true)` and asserted before the check); and the frame a panel mounts into is built with the toolbar's choosing state, with no rebuild, which pins the order of the two subscriptions. - `workflow-editor.component.spec.ts`: wiring the highlight handler into a selection the wrapper already holds rings that operator once (a spy installed after the stream has done its work). - `workflow-form.component.spec.ts`: the form's step panel opens on the step the canvas had selected, and stays closed for none or several — seeded with a stale id, so a read that never happened could not pass as "undefined". - Existing specs for all three components pass unchanged; they cover what the streams do after mount. - The full frontend suite, eslint, prettier and the production (AOT) build pass. - By hand on a local deployment, `main` (`cfca8e1e5`) and this branch served side by side on the same backend and the same workflow, driven by a Playwright probe that reads what the panel shows at each step: | step | main | this branch | | --- | --- | --- | | click the step on the canvas | the step | the step | | switch to the Form View | empty | the step, ringed on the preview | | click that same step on the preview | empty | the step | | switch back to the canvas | empty | the step, ringed on the canvas | ### Was this PR authored or co-authored using generative AI tooling? Yes. Generated-by: Claude Code (Claude Fable 5.1, Anthropic). Co-authored with Claude, reviewed line by line by the author before submission. 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Fable 5.1 <[email protected]>
1 parent ada1cfe commit ad085e9

7 files changed

Lines changed: 191 additions & 49 deletions

File tree

‎frontend/src/app/workspace/component/property-editor/property-editor.component.spec.ts‎

Lines changed: 66 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -147,6 +147,72 @@ describe("PropertyEditorComponent", () => {
147147
expect(getById).not.toHaveBeenCalledWith("right-container");
148148
});
149149

150+
// The selection lives in the graph wrapper, which both views of a workflow share and hand over
151+
// between them: a panel that only followed the streams stayed empty on arrival, since the event
152+
// that made the selection fired before it existed -- and clicking the selected operator emits
153+
// nothing, so it took clicking a different one to bring the panel back. ngOnInit is re-run on the
154+
// live fixture, which is what a fresh mount into the same shared selection comes down to.
155+
it("shows what is already selected when it mounts, not only what is selected next", () => {
156+
const jointGraphWrapper = workflowActionService.getJointGraphWrapper();
157+
workflowActionService.addOperator(mockScanPredicate, mockPoint);
158+
jointGraphWrapper.highlightOperators(mockScanPredicate.operatorID);
159+
// As a panel that was not there when the selection was made: it has shown nothing so far.
160+
component.currentComponent = null;
161+
component.componentInputs = {};
162+
163+
component.ngOnInit();
164+
165+
expect(component.currentComponent).toBe(OperatorPropertyEditFrameComponent);
166+
expect(component.componentInputs).toEqual(
167+
expect.objectContaining({ currentOperatorId: mockScanPredicate.operatorID })
168+
);
169+
});
170+
171+
it("leaves the panel alone when it mounts into no selection, and shows no frame into several", () => {
172+
const jointGraphWrapper = workflowActionService.getJointGraphWrapper();
173+
// Nothing selected: the no-frame branch is for a selection being dropped (it clears the
174+
// editing marker and resizes the docked panel), so a fresh mount must not run it.
175+
component.currentComponent = OperatorPropertyEditFrameComponent;
176+
component.ngOnInit();
177+
expect(component.currentComponent).toBe(OperatorPropertyEditFrameComponent);
178+
179+
// Two selected: a selection exists but no single step to show, so no frame.
180+
workflowActionService.addOperatorsAndLinks(
181+
[
182+
{ op: mockScanPredicate, pos: mockPoint },
183+
{ op: mockResultPredicate, pos: mockPoint },
184+
],
185+
[]
186+
);
187+
jointGraphWrapper.setMultiSelectMode(true);
188+
jointGraphWrapper.highlightOperators(mockScanPredicate.operatorID, mockResultPredicate.operatorID);
189+
expect(jointGraphWrapper.getCurrentHighlightedOperatorIDs()).toHaveLength(2);
190+
component.currentComponent = OperatorPropertyEditFrameComponent;
191+
192+
component.ngOnInit();
193+
expect(component.currentComponent).toBeNull();
194+
});
195+
196+
// The toolbar's choosing toggle replays its current value on subscribe. A frame built before
197+
// that replay would be built without it and then torn down and rebuilt by it, inside the page's
198+
// first change-detection pass; so the mount-time read comes after the subscription. Checked on
199+
// a panel whose own toggle state is fresh, as a mounting panel's is.
200+
it("builds the frame it mounts into with the toolbar's choosing state, without a rebuild", () => {
201+
const jointGraphWrapper = workflowActionService.getJointGraphWrapper();
202+
workflowActionService.addOperator(mockScanPredicate, mockPoint);
203+
jointGraphWrapper.highlightOperators(mockScanPredicate.operatorID);
204+
TestBed.inject(FormBindingService).setChoosing(true);
205+
component.currentComponent = null;
206+
component.componentInputs = {};
207+
(component as unknown as { choosingFromToolbar: boolean }).choosingFromToolbar = false;
208+
209+
component.ngOnInit();
210+
211+
// Built once, with choosing on -- not built off and then nulled by the replay for a rebuild.
212+
expect(component.currentComponent).toBe(OperatorPropertyEditFrameComponent);
213+
expect(component.componentInputs).toEqual(expect.objectContaining({ exposeChoosing: true }));
214+
});
215+
150216
/**
151217
* test if the property editor correctly receives the operator unhighlight stream
152218
* and clears all the operator data, and hide the form.

‎frontend/src/app/workspace/component/property-editor/property-editor.component.ts‎

Lines changed: 57 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,7 @@ import { merge } from "rxjs";
3535
import { WorkflowActionService } from "../../service/workflow-graph/model/workflow-action.service";
3636
import { OperatorPropertyEditFrameComponent } from "./operator-property-edit-frame/operator-property-edit-frame.component";
3737
import { UntilDestroy, untilDestroyed } from "@ngneat/until-destroy";
38-
import { distinctUntilChanged, filter } from "rxjs/operators";
38+
import { distinctUntilChanged } from "rxjs/operators";
3939
import { PortPropertyEditFrameComponent } from "./port-property-edit-frame/port-property-edit-frame.component";
4040
import { NzResizeEvent, NzResizableDirective, NzResizeHandlesComponent } from "ng-zorro-antd/resizable";
4141
import { calculateTotalTranslate3d } from "../../../common/util/panel-dock";
@@ -171,7 +171,6 @@ export class PropertyEditorComponent implements OnInit, OnDestroy, OnChanges {
171171
const [xOffset, yOffset, _] = calculateTotalTranslate3d(container.style.transform);
172172
this.returnPosition = { x: -xOffset, y: -yOffset };
173173
}
174-
this.registerHighlightEventsHandler();
175174
// The toolbar's "choose fields" toggle lives in the service so both the canvas toolbar
176175
// and this panel see the same state. Re-emit the frame's inputs when it changes, so tick
177176
// boxes appear and disappear without needing a re-selection.
@@ -187,6 +186,10 @@ export class PropertyEditorComponent implements OnInit, OnDestroy, OnChanges {
187186
// Rebuild the frame so the tick boxes appear/disappear (see remountOperatorFrame).
188187
this.remountOperatorFrame();
189188
});
189+
// After the toggle above has replayed its current value: the frame this may build on mount
190+
// takes `choosing` from it, and building first would have the replay tear the frame down and
191+
// rebuild it inside the page's first change-detection pass.
192+
this.registerHighlightEventsHandler();
190193
this.panelService.closePanelStream.pipe(untilDestroyed(this)).subscribe(() => this.closePanel());
191194
this.panelService.resetPanelStream.pipe(untilDestroyed(this)).subscribe(() => {
192195
this.resetPanelPosition();
@@ -257,13 +260,23 @@ export class PropertyEditorComponent implements OnInit, OnDestroy, OnChanges {
257260
}
258261

259262
/**
260-
* This method changes the property editor according to how operators are highlighted on the workflow editor.
261-
*
262-
* Displays the form of the highlighted operator if only one operator is highlighted;
263-
* Displays the form of the link breakpoint if only one link is highlighted;
264-
* hides the form if no operator/link is highlighted or multiple operators and/or links are highlighted.
263+
* Shows the selection the panel mounts into, then follows every change to it: one operator or
264+
* one port opens its frame, anything else (nothing, several things, a link) shows no frame.
265265
*/
266266
registerHighlightEventsHandler() {
267+
// The selection outlives this panel: it lives in the graph wrapper, which both views of a
268+
// workflow share and hand over between them, so a panel mounting into an existing selection
269+
// never sees the event that made it. Show it now, then follow the changes -- otherwise the
270+
// panel looks empty until the selection changes, and clicking the very step it should be
271+
// showing is a no-op (an already-highlighted element emits nothing). Only when something is
272+
// selected: a fresh mount has no frame to clear, and the no-frame branch is for a selection
273+
// being dropped (it clears the editing marker and resizes the docked panel to its empty
274+
// content), which a mount must not do. A link or a comment box alone leaves the panel as it
275+
// mounted, empty -- what the branch would have shown anyway.
276+
const wrapper = this.workflowActionService.getJointGraphWrapper();
277+
if (wrapper.getCurrentHighlightedOperatorIDs().length > 0 || wrapper.getCurrentHighlightedPortIDs().length > 0) {
278+
this.showHighlighted();
279+
}
267280
merge(
268281
this.workflowActionService.getJointGraphWrapper().getJointOperatorHighlightStream(),
269282
this.workflowActionService.getJointGraphWrapper().getJointOperatorUnhighlightStream(),
@@ -274,40 +287,44 @@ export class PropertyEditorComponent implements OnInit, OnDestroy, OnChanges {
274287
this.workflowActionService.getJointGraphWrapper().getJointPortHighlightStream(),
275288
this.workflowActionService.getJointGraphWrapper().getJointPortUnhighlightStream()
276289
)
277-
.pipe(
278-
filter(() => this.workflowActionService.getTexeraGraph().getSyncTexeraGraph()),
279-
untilDestroyed(this)
280-
)
281-
.subscribe(_ => {
282-
const highlightedOperators = this.workflowActionService
283-
.getJointGraphWrapper()
284-
.getCurrentHighlightedOperatorIDs();
285-
const highlightLinks = this.workflowActionService.getJointGraphWrapper().getCurrentHighlightedLinkIDs();
286-
this.workflowActionService.getJointGraphWrapper().getCurrentHighlightedCommentBoxIDs();
287-
const highlightedPorts = this.workflowActionService.getJointGraphWrapper().getCurrentHighlightedPortIDs();
290+
.pipe(untilDestroyed(this))
291+
.subscribe(_ => this.showHighlighted());
292+
}
288293

289-
if (highlightedOperators.length === 1 && highlightLinks.length === 0 && highlightedPorts.length === 0) {
290-
this.currentComponent = OperatorPropertyEditFrameComponent;
291-
this.componentInputs = {
292-
currentOperatorId: highlightedOperators[0],
293-
exposeChoosing: this.choosing,
294-
actsAsEditor: this.actsAsEditor,
295-
};
296-
} else if (highlightedPorts.length === 1 && highlightLinks.length === 0) {
297-
this.currentComponent = PortPropertyEditFrameComponent;
298-
this.componentInputs = { currentPortID: highlightedPorts[0] };
299-
} else {
300-
this.currentComponent = null;
301-
this.componentInputs = {};
302-
// Same gate as the frame's own broadcast: a viewer mount publishes nothing on the
303-
// shared awareness channel, in either direction.
304-
if (this.actsAsEditor) {
305-
this.workflowActionService.getTexeraGraph().updateSharedModelAwareness("currentlyEditing", undefined);
306-
}
307-
}
308-
this.changeDetectorRef.detectChanges();
309-
this.updateHeightBasedOnContent();
310-
});
294+
/**
295+
* Show whatever the shared selection holds right now: one operator, one port, or nothing. Not
296+
* while the graph is mid-sync with the shared model: the highlight set is then in flux and would
297+
* be read again when the sync ends.
298+
*/
299+
private showHighlighted(): void {
300+
if (!this.workflowActionService.getTexeraGraph().getSyncTexeraGraph()) {
301+
return;
302+
}
303+
const highlightedOperators = this.workflowActionService.getJointGraphWrapper().getCurrentHighlightedOperatorIDs();
304+
const highlightedLinks = this.workflowActionService.getJointGraphWrapper().getCurrentHighlightedLinkIDs();
305+
const highlightedPorts = this.workflowActionService.getJointGraphWrapper().getCurrentHighlightedPortIDs();
306+
307+
if (highlightedOperators.length === 1 && highlightedLinks.length === 0 && highlightedPorts.length === 0) {
308+
this.currentComponent = OperatorPropertyEditFrameComponent;
309+
this.componentInputs = {
310+
currentOperatorId: highlightedOperators[0],
311+
exposeChoosing: this.choosing,
312+
actsAsEditor: this.actsAsEditor,
313+
};
314+
} else if (highlightedPorts.length === 1 && highlightedLinks.length === 0) {
315+
this.currentComponent = PortPropertyEditFrameComponent;
316+
this.componentInputs = { currentPortID: highlightedPorts[0] };
317+
} else {
318+
this.currentComponent = null;
319+
this.componentInputs = {};
320+
// Same gate as the frame's own broadcast: a viewer mount publishes nothing on the
321+
// shared awareness channel, in either direction.
322+
if (this.actsAsEditor) {
323+
this.workflowActionService.getTexeraGraph().updateSharedModelAwareness("currentlyEditing", undefined);
324+
}
325+
}
326+
this.changeDetectorRef.detectChanges();
327+
this.updateHeightBasedOnContent();
311328
}
312329
onResize({ width, height }: NzResizeEvent) {
313330
cancelAnimationFrame(this.id);

‎frontend/src/app/workspace/component/workflow-editor/workflow-editor.component.spec.ts‎

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -669,6 +669,25 @@ describe("WorkflowEditorComponent", () => {
669669
expect(model.attr(".add-input-port-button/visibility")).toBe("hidden");
670670
expect(model.attr(".texera-operator-state/visibility")).toBe("visible");
671671
});
672+
673+
// The selection lives in the wrapper, which both views of a workflow share and hand over
674+
// between them, while this paper is new on every switch: a paper that only followed the
675+
// highlight stream left the step the other view had selected drawn as not selected, beside a
676+
// panel showing it. The highlight handler is re-run here, which is what a new paper wiring
677+
// itself into the same shared selection comes down to.
678+
it("rings the operators the shared selection already holds when the paper wires itself up", () => {
679+
const workflowActionService = TestBed.inject(WorkflowActionService);
680+
workflowActionService.addOperator(mockScanPredicate, mockPoint);
681+
workflowActionService.getJointGraphWrapper().highlightOperators(mockScanPredicate.operatorID);
682+
const view = component.paper.findViewByModel(mockScanPredicate.operatorID);
683+
// Installed after the stream has done its work, so only the wiring-up pass is counted.
684+
const highlight = vi.spyOn(view, "highlight");
685+
686+
(component as unknown as { handleElementHightlightEvent: () => void }).handleElementHightlightEvent();
687+
688+
expect(highlight).toHaveBeenCalledTimes(1);
689+
expect(highlight).toHaveBeenCalledWith("rect.body", expect.anything());
690+
});
672691
});
673692

674693
/**

‎frontend/src/app/workspace/component/workflow-editor/workflow-editor.component.ts‎

Lines changed: 12 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1213,14 +1213,21 @@ export class WorkflowEditorComponent implements OnInit, AfterViewInit, OnDestroy
12131213
},
12141214
};
12151215

1216+
const ring = (elementID: string) =>
1217+
this.paper.findViewByModel(elementID)?.highlight("rect.body", { highlighter: highlightOptions });
1218+
1219+
// The selection outlives this paper: it lives in the wrapper, which both views of a workflow
1220+
// share and hand over between them, while the paper is new on every switch. Ring what is
1221+
// selected now, or the view arriving at a selection would show its panel for a step drawn as
1222+
// not selected; then follow the changes.
1223+
[...this.wrapper.getCurrentHighlightedOperatorIDs(), ...this.wrapper.getCurrentHighlightedCommentBoxIDs()].forEach(
1224+
ring
1225+
);
1226+
12161227
// highlight on OperatorHighlightStream or CommentBoxHighlightStream
12171228
merge(this.wrapper.getJointOperatorHighlightStream(), this.wrapper.getJointCommentBoxHighlightStream())
12181229
.pipe(untilDestroyed(this))
1219-
.subscribe(elementIDs =>
1220-
elementIDs.forEach(elementID => {
1221-
this.paper.findViewByModel(elementID).highlight("rect.body", { highlighter: highlightOptions });
1222-
})
1223-
);
1230+
.subscribe(elementIDs => elementIDs.forEach(ring));
12241231

12251232
// unhighlight on OperatorUnhighlightStream or CommentBoxUnhighlightStream
12261233
merge(this.wrapper.getJointOperatorUnhighlightStream(), this.wrapper.getJointCommentBoxUnhighlightStream())

‎frontend/src/app/workspace/component/workflow-form/workflow-form.component.html‎

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -468,10 +468,9 @@ <h2>{{ instructionTitle || "How to use this" }}</h2>
468468
inert mount and turns live when the run ends. The panel's own tab stop goes away with
469469
inert, so it does not sit in front of the form it now contains. persistPlacement stays
470470
off either way (this is not the docked canvas panel).
471-
[hidden], not *ngIf: the property editor shows its operator by REACTING to the highlight
472-
stream (no initial pull), so it must already be mounted and subscribed when the click
473-
highlights a step. Mounting it on selection (*ngIf) subscribes too late, misses that
474-
emission, and the panel opens empty. So keep it mounted and just hide it. -->
471+
[hidden], not *ngIf: one mounted panel keeps its subscriptions, its frame and its size
472+
across selections, where mounting it per step (*ngIf) would rebuild all of that on
473+
every click. So keep it mounted and just hide it. -->
475474
<div
476475
class="panel"
477476
role="group"

‎frontend/src/app/workspace/component/workflow-form/workflow-form.component.spec.ts‎

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2657,6 +2657,36 @@ describe("WorkflowFormComponent", () => {
26572657
expect(workflowActionService.setHighlightingEnabled).toHaveBeenCalledWith(true);
26582658
});
26592659

2660+
// The selection is the canvas's too: the wrapper holding it is handed over, not rebuilt, when
2661+
// the views switch. A step chosen on the canvas is therefore already selected on arrival here,
2662+
// and no stream will say so -- the panel stayed shut until the reader clicked a DIFFERENT step
2663+
// (clicking the selected one emits nothing).
2664+
it("opens the panel for the step the canvas had selected, with no click of its own", () => {
2665+
withOp();
2666+
h.highlightedIds.push("op-1");
2667+
2668+
build(formViewWorkflow).ngOnInit();
2669+
2670+
expect(component.selectedOperatorId).toBe("op-1");
2671+
});
2672+
2673+
it("arrives with no panel when the canvas had nothing, or more than one step, selected", () => {
2674+
withOp();
2675+
h.hasOperatorIds.add("op-2");
2676+
h.graphOperators.push({ operatorID: "op-2", operatorType: "Filter" });
2677+
// Seeded with a stale id, so a read that never happened would not pass as "undefined".
2678+
let c = build(formViewWorkflow);
2679+
c.selectedOperatorId = "op-1";
2680+
c.ngOnInit();
2681+
expect(c.selectedOperatorId).toBeUndefined();
2682+
2683+
h.highlightedIds.push("op-1", "op-2");
2684+
c = build(formViewWorkflow);
2685+
c.selectedOperatorId = "op-1";
2686+
c.ngOnInit();
2687+
expect(c.selectedOperatorId).toBeUndefined();
2688+
});
2689+
26602690
it("opens the read-only panel for the clicked step", () => {
26612691
build(formViewWorkflow).ngOnInit();
26622692
withOp();

‎frontend/src/app/workspace/component/workflow-form/workflow-form.component.ts‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -367,6 +367,10 @@ export class WorkflowFormComponent implements OnInit, OnDestroy {
367367
.pipe(untilDestroyed(this))
368368
.subscribe(() => this.syncSelectionFromHighlight());
369369

370+
// And once now: the selection is the canvas's too, handed over rather than rebuilt when the
371+
// views switch, so a step chosen there is already selected here and no event will say so.
372+
this.syncSelectionFromHighlight();
373+
370374
// A result changing bumps that operator's version (so its chart frame is rebuilt, not reused),
371375
// re-limits what the form shows to the currently-viewed set, and re-fits the visualisations.
372376
this.workflowResultService

0 commit comments

Comments
 (0)