diff --git a/packages/merman/src/flowchart/flowchart.test.ts b/packages/merman/src/flowchart/flowchart.test.ts index cd85dc8a960..323c75d2704 100644 --- a/packages/merman/src/flowchart/flowchart.test.ts +++ b/packages/merman/src/flowchart/flowchart.test.ts @@ -1017,6 +1017,51 @@ flowchart LR } }) + test("separates cross-dependent top-level subgraphs", () => { + const content = `flowchart TD + subgraph plugins["Plugins — one verb: attach"] + chip["pr-indicator
attach(prompt.footer, { after: 'directory' })"] + theme["fancy-footer
attach(prompt.footer, { replace: 'right' })"] + end + + subgraph host["Host anatomy tree — published, stable part IDs"] + footer["prompt.footer"] + left["left"] + right["right
(container)"] + dir["directory"] + model["model"] + tokens["tokens"] + footer --> left + footer --> right + right --> dir + right --> model + right --> tokens + end + + chip -- "insert after" --> dir + theme == "takeover" ==> right + theme -. "suppresses guests
in subtree" .-> chip` + const layout = layoutFlowchartDiagram(content) + const plugins = layout.subgraphBounds.get("plugins")! + const host = layout.subgraphBounds.get("host")! + const output = renderFlowchartDiagram(content) + const lines = output.split("\n") + + expect(host.top).toBeGreaterThanOrEqual(plugins.top + plugins.height) + expect(lines.filter((line) => line.includes("Plugins — one verb: attach"))).toHaveLength(1) + expect(lines.filter((line) => line.includes("Host anatomy tree — published, stable part IDs"))).toHaveLength(1) + expect(lines.findIndex((line) => line.includes("Host anatomy tree"))).toBeGreaterThan( + lines.findIndex((line) => line.includes("Plugins — one verb")), + ) + for (const route of layout.routes) { + for (let index = 1; index < route.points.length; index++) { + const from = route.points[index - 1]! + const to = route.points[index]! + expect(from.x === to.x || from.y === to.y).toBe(true) + } + } + }) + test("moves subgraph labels away from crossing routes", () => { const output = renderFlowchartDiagram(` flowchart TD diff --git a/packages/merman/src/flowchart/layout.ts b/packages/merman/src/flowchart/layout.ts index 6b00a1aad5e..653ddbf8ac1 100644 --- a/packages/merman/src/flowchart/layout.ts +++ b/packages/merman/src/flowchart/layout.ts @@ -499,10 +499,6 @@ function edgeDirection(diagram: FlowchartDiagram, edge: FlowchartEdge): Flowchar return diagram.direction } -function hasLocalSubgraphDirection(diagram: FlowchartDiagram): boolean { - return (diagram.subgraphs ?? []).some((subgraph) => subgraph.direction && subgraph.direction !== diagram.direction) -} - function collectSubgraphNodeIds(diagram: FlowchartDiagram, subgraphId: string): Set { const nodeIds = new Set() for (const subgraph of diagram.subgraphs ?? []) { @@ -515,47 +511,113 @@ function collectSubgraphNodeIds(diagram: FlowchartDiagram, subgraphId: string): return nodeIds } -function separateLocalSubgraphItems( +function separateTopLevelItems( diagram: FlowchartDiagram, nodeBounds: Map, subgraphBounds: ReadonlyMap, gap: number, ): void { - if (!hasLocalSubgraphDirection(diagram)) return - + const hasLocalDirection = (diagram.subgraphs ?? []).some( + (subgraph) => subgraph.direction && subgraph.direction !== diagram.direction, + ) const coveredNodeIds = new Set() - const items: { bounds: FlowchartBounds; nodeIds: Set }[] = [] + const items: { id: string; bounds: FlowchartBounds; nodeIds: Set; rank: number }[] = [] + const itemByEndpoint = new Map() for (const subgraph of diagram.subgraphs ?? []) { if (subgraph.parentId) continue const bounds = subgraphBounds.get(subgraph.id) const nodeIds = collectSubgraphNodeIds(diagram, subgraph.id) if (!bounds || nodeIds.size === 0) continue - items.push({ bounds, nodeIds }) - for (const nodeId of nodeIds) coveredNodeIds.add(nodeId) + items.push({ id: subgraph.id, bounds, nodeIds, rank: 0 }) + itemByEndpoint.set(subgraph.id, subgraph.id) + for (const nodeId of nodeIds) { + coveredNodeIds.add(nodeId) + itemByEndpoint.set(nodeId, subgraph.id) + } } for (const node of diagram.nodes) { if (coveredNodeIds.has(node.id)) continue const bounds = nodeBounds.get(node.id) - if (bounds) items.push({ bounds, nodeIds: new Set([node.id]) }) + if (!bounds) continue + items.push({ id: node.id, bounds, nodeIds: new Set([node.id]), rank: 0 }) + itemByEndpoint.set(node.id, node.id) } + if (items.length < 2) return const horizontal = isHorizontalDirection(diagram.direction) - items.sort((a, b) => (horizontal ? a.bounds.left - b.bounds.left : a.bounds.top - b.bounds.top)) + if (hasLocalDirection) { + items.sort((a, b) => (horizontal ? a.bounds.left - b.bounds.left : a.bounds.top - b.bounds.top)) + let cursor: number | undefined + for (const item of items) { + const start = horizontal ? item.bounds.left : item.bounds.top + const size = horizontal ? item.bounds.width : item.bounds.height + if (cursor === undefined) { + cursor = start + size + gap + continue + } + const shift = cursor - start + for (const nodeId of item.nodeIds) { + const bounds = nodeBounds.get(nodeId) + if (bounds) translateBounds(bounds, horizontal ? shift : 0, horizontal ? 0 : shift) + } + cursor = start + shift + size + gap + } + return + } + + const topLevelIds = new Set( + (diagram.subgraphs ?? []).filter((subgraph) => !subgraph.parentId).map((subgraph) => subgraph.id), + ) + const rankedItems = items.filter((item) => topLevelIds.has(item.id)) + if (rankedItems.length < 2) return + + const itemById = new Map(rankedItems.map((item) => [item.id, item])) + const outgoing = new Map(rankedItems.map((item) => [item.id, new Set()])) + const incoming = new Map(rankedItems.map((item) => [item.id, 0])) + for (const edge of diagram.edges) { + const from = itemByEndpoint.get(edge.from) + const to = itemByEndpoint.get(edge.to) + if (!from || !to || from === to || !itemById.has(from) || !itemById.has(to) || outgoing.get(from)!.has(to)) continue + outgoing.get(from)!.add(to) + incoming.set(to, incoming.get(to)! + 1) + } + + const queue = rankedItems.filter((item) => incoming.get(item.id) === 0) + for (let index = 0; index < queue.length; index++) { + const item = queue[index]! + for (const to of outgoing.get(item.id)!) { + const downstream = itemById.get(to)! + downstream.rank = Math.max(downstream.rank, item.rank + 1) + incoming.set(to, incoming.get(to)! - 1) + if (incoming.get(to) === 0) queue.push(downstream) + } + } + + const reversed = diagram.direction === "RL" || diagram.direction === "BT" + const primaryStart = (item: (typeof items)[number]): number => { + const start = horizontal ? item.bounds.left : item.bounds.top + const size = horizontal ? item.bounds.width : item.bounds.height + return reversed ? -(start + size) : start + } + rankedItems.sort((a, b) => a.rank - b.rank || primaryStart(a) - primaryStart(b)) let cursor: number | undefined - for (const item of items) { - const start = horizontal ? item.bounds.left : item.bounds.top + for (const item of rankedItems) { + const start = primaryStart(item) const size = horizontal ? item.bounds.width : item.bounds.height if (cursor === undefined) { cursor = start + size + gap continue } - const shift = cursor - start - if (shift !== 0) { + const shift = Math.max(0, cursor - start) + if (shift > 0) { for (const nodeId of item.nodeIds) { const bounds = nodeBounds.get(nodeId) - if (bounds) translateBounds(bounds, horizontal ? shift : 0, horizontal ? 0 : shift) + if (bounds) { + const offset = reversed ? -shift : shift + translateBounds(bounds, horizontal ? offset : 0, horizontal ? 0 : offset) + } } } cursor = start + shift + size + gap @@ -616,7 +678,7 @@ function layoutFlowchartWithDirection( let routes = routeFlowchartEdges(diagram, bounds, (edge) => edgeDirection(diagram, edge)) let subgraphBounds = layoutSubgraphs(diagram, bounds, routes) - separateLocalSubgraphItems(diagram, bounds, subgraphBounds, Math.max(1, Math.floor(requestedMinRankGap / 2))) + separateTopLevelItems(diagram, bounds, subgraphBounds, Math.max(1, Math.floor(requestedMinRankGap / 2))) routes = routeFlowchartEdges(diagram, bounds, (edge) => edgeDirection(diagram, edge)) subgraphBounds = layoutSubgraphs(diagram, bounds, routes) routes = routeFlowchartEdges(diagram, bounds, (edge) => edgeDirection(diagram, edge), subgraphBounds)