Description

Fix Sankey layout freezing on dense, heavily branching graphs by pruning depth assignment in updateDepthOfTargets.

When computing node depth (longest path from a source), the layout recurses into every target even when depth does not grow. On graphs where many paths share nodes, that re-walks every distinct path combinatorially. The freeze is not limited to very large datasets — it can happen with modest node/link counts when the graph branches heavily.

The fix only recurses when curNode.depth + 1 exceeds the target's current depth. Once depth stops increasing, the subtree is already correct.

Also exports computeData from Sankey.tsx for unit tests (same pattern as Treemap's computeNode). It is not added to src/index.ts, so the public API is unchanged. New test coverage is described below.

Related Issue

#7478

Motivation and Context

Sankey layout can freeze the browser when depth assignment must follow the longest path to each node. Without pruning, the layout walks every distinct path combinatorially.

Starting from relatively small graphs, this is already a problem — not only at “big data” scale. For example, the issue reproducer uses only 85 nodes and 112 links (makeBranchingChainData(28)).

The cost is driven by path count (how many distinct routes exist through shared nodes), not by raw node/link totals alone. Modest node/link counts can still hang when the graph branches heavily.

The fix is a small guard in updateDepthOfTargets. Existing Sankey tests that pin exact coordinates still pass, so layout geometry for typical graphs is unchanged.

How Has This Been Tested?

Added unit tests in test/chart/Sankey.spec.tsx covering the Sankey layout for large, heavily branching graphs:

• Depth correctness: verifies a node's depth is the longest path from a source, even when links skip layers (e.g. a 0 -> 1 -> 2 chain plus a 0 -> 2 shortcut resolves node 2 to depth 2, not 1).
• Performance regression guard: builds a chain of 28 branching segments (small node/link count but 2 ** 28 distinct paths) and asserts computeData returns all nodes with the expected max depth, completing well within vitest's default timeout — the previous, unfixed implementation would time out on this input.
• Rendering: renders with the same branching graph and checks all node and link elements are present.

Screenshots (if appropriate):

N/A — performance fix with no visual change for existing graphs.

Types of changes

• Bug fix (non-breaking change which fixes an issue)
• New feature (non-breaking change which adds functionality)
• Breaking change (fix or feature that would cause existing functionality to change)

Checklist:

• My change requires a change to the documentation.
• I have updated the documentation accordingly.
• I have added tests to cover my changes.
• I have added a storybook story or VR test, or extended an existing story or VR test to show my changes

Summary by CodeRabbit

Release Notes

• Bug Fixes

  • Improved Sankey layout depth propagation to avoid redundant recalculations and better handle complex branching graphs, resulting in more reliable node positioning.

• Tests

  • Added new Sankey tests using large, heavily branching datasets to verify depth assignment and expected rendered node/link counts.