fix: implement custom path calculation for collapsed node chains

- Add createViewObjectForCollapsedChain() static method to handle path routing between start/end nodes

- Replace standard TrainrunSectionViewObject creation with custom method for collapsed chains

- Path now correctly goes from first visible node to last visible node instead of using primary section's path

Author: Math-R

src/app/view/editor-main-view/data-views/connections.view.ts

@@ -240,6 +240,12 @@ export class ConnectionsView {
     }
 
     const node: Node = this.editorView.getNodeFromConnection(con);
+
+    // filter if node is collapsed - do not show connections for collapsed nodes
+    if (node.getIsCollapsed()) {
+      return false;
+    }
+
     const trainrunSection1: TrainrunSection = node.getPort(con.getPortId1()).getTrainrunSection();
     const trainrunSection2: TrainrunSection = node.getPort(con.getPortId2()).getTrainrunSection();
     const filterTrainrun1 = this.editorView.filterTrainrun(trainrunSection1.getTrainrun());

src/app/view/editor-main-view/data-views/trainrunsections.view.ts

@@ -152,6 +152,79 @@ export class TrainrunSectionsView {
     return atSource ? trainrunSection.getSourceNode() : trainrunSection.getTargetNode();
   }
 
+  /**
+   * Creates a TrainrunSectionViewObject for collapsed node chains where the visual path
+   * goes directly from startNode to endNode instead of using the primary section's path.
+   * This is used when intermediate nodes are collapsed and should not be visible.
+   */
+  static createViewObjectForCollapsedChain(
+    editorView: EditorView,
+    primarySection: TrainrunSection,
+    allSections: TrainrunSection[],
+    startNode: Node,
+    endNode: Node,
+    isNonStopAtSource: boolean,
+    isNonStopAtTarget: boolean,
+    isMuted: boolean,
+    hiddenTagSource: boolean,
+    hiddenTagTarget: boolean,
+    hiddenTagTraveltime: boolean,
+    hiddenTagTrainrunName: boolean,
+    hiddenTagDirectionArrows: boolean,
+  ): TrainrunSectionViewObject {
+    // Create a standard view object first
+    const viewObject = new TrainrunSectionViewObject(
+      editorView,
+      primarySection,
+      isNonStopAtSource,
+      isNonStopAtTarget,
+      isMuted,
+      hiddenTagSource,
+      hiddenTagTarget,
+      hiddenTagTraveltime,
+      hiddenTagTrainrunName,
+      hiddenTagDirectionArrows,
+    );
+
+    // Override the path calculation to use startNode and endNode
+    // We need to temporarily modify the primary section's nodes for path calculation
+    const originalSourceNode = primarySection.getSourceNode();
+    const originalTargetNode = primarySection.getTargetNode();
+    const originalSourcePortId = primarySection.getSourcePortId();
+    const originalTargetPortId = primarySection.getTargetPortId();
+
+    try {
+      // Set temporary nodes for path calculation
+      primarySection.setSourceNode(startNode);
+      primarySection.setTargetNode(endNode);
+
+      // Find appropriate ports using the correct sections from the chain
+      // Source port: from the first section of the chain
+      // Target port: from the last section of the chain
+      const firstSection = allSections[0];
+      const lastSection = allSections[allSections.length - 1];
+
+      const sourcePort =
+        startNode.getPortOfTrainrunSection(firstSection.getId()) || startNode.getPorts()[0];
+      const targetPort =
+        endNode.getPortOfTrainrunSection(lastSection.getId()) || endNode.getPorts()[0];
+
+      primarySection.setSourcePortId(sourcePort.getId());
+      primarySection.setTargetPortId(targetPort.getId());
+
+      // Recalculate path with new nodes
+      primarySection.routeEdgeAndPlaceText();
+    } finally {
+      // Restore original nodes and ports
+      primarySection.setSourceNode(originalSourceNode);
+      primarySection.setTargetNode(originalTargetNode);
+      primarySection.setSourcePortId(originalSourcePortId);
+      primarySection.setTargetPortId(originalTargetPortId);
+    }
+
+    return viewObject;
+  }
+
   static hasWarning(trainrunSection: TrainrunSection, textElement: TrainrunSectionText): boolean {
     switch (textElement) {
       case TrainrunSectionText.SourceDeparture:
@@ -1690,9 +1763,12 @@ export class TrainrunSectionsView {
         const primarySection = group.sections[0];
         const lastSection = group.sections[group.sections.length - 1];
         viewTrainrunSectionDataObjects.push(
-          new TrainrunSectionViewObject(
+          TrainrunSectionsView.createViewObjectForCollapsedChain(
             editorView,
             primarySection,
+            group.sections,
+            group.startNode,
+            group.endNode,
             group.startNode.isNonStop(primarySection),
             group.endNode.isNonStop(lastSection),
             TrainrunSectionsView.isMuted(primarySection, selectedTrainrun, connectedTrainIds),

src/app/view/editor-main-view/data-views/transitions.view.ts

@@ -177,6 +177,11 @@ export class TransitionsView {
     }
 
     const node = this.editorView.getNodeFromTransition(transition);
+
+    if (node.getIsCollapsed()) {
+      return false;
+    }
+
     if (!this.editorView.checkFilterNonStopNode(node)) {
       return false;
     }