fix(sankey): derive effective node.pad clamp from layout geometry

The node.pad warning read the clamped padding back through
sankey.nodePadding(). In @plotly/d3-sankey@0.7.x that getter returns
the post-layout clamped value, but since 0.12.x (upstream split of dy/py)
it returns the configured value, so the comparison is never true and the
warning never fires after a dependency upgrade.

Measure the smallest vertical gap between consecutive nodes in any one
column instead; this works regardless of the installed d3-sankey
version. Regression tests cover both the clamped and non-clamped paths.

Refs #7832

Author: CAOShurong

src/traces/sankey/render.js

@@ -73,8 +73,30 @@ function sankeyModel(layout, d, traceIndex) {
 
     var graph = sankey();
 
-    if(sankey.nodePadding() < nodePad) {
-        Lib.warn('node.pad was reduced to ', sankey.nodePadding(), ' to fit within the figure.');
+    // Derive the effective (post-clamp) node padding from the laid-out node
+    // geometry instead of reading it back through `sankey.nodePadding()`.
+    // In @plotly/d3-sankey@0.7.x that getter returned the clamped value after
+    // the layout ran, but since 0.12.x it returns the user-configured value
+    // (upstream split `dy` from `py`), so a getter-based check would never
+    // fire. Measuring the smallest vertical gap between consecutive nodes in
+    // any one column is version-independent. See #7832.
+    var effectivePad = nodePad;
+    var columns = {};
+    graph.nodes.forEach(function(node) {
+        var col = Math.round(node.x0);
+        if(!columns[col]) columns[col] = [];
+        columns[col].push([node.y0, node.y1]);
+    });
+    for(var key in columns) {
+        var column = columns[key].sort(function(a, b) { return a[0] - b[0]; });
+        for(i = 1; i < column.length; i++) {
+            var gap = column[i][0] - column[i - 1][1];
+            if(gap < effectivePad) effectivePad = gap;
+        }
+    }
+
+    if(effectivePad < nodePad) {
+        Lib.warn('node.pad was reduced to ', effectivePad, ' to fit within the figure.');
     }
 
     // Counters for nested loops

test/jasmine/tests/sankey_test.js

@@ -95,6 +95,62 @@ describe('sankey tests', function() {
         });
     });
 
+    describe('node.pad reduction warning', function() {
+        // The warning must be driven by the effective (post-clamp) padding,
+        // not by reading `sankey.nodePadding()` back, which since
+        // @plotly/d3-sankey@0.12.x returns the configured value instead of
+        // the clamped one - see #7832.
+        var padMock = [{
+            type: 'sankey',
+            layoutversion: 2,
+            domain: {x: [0, 1], y: [0, 1]},
+            node: {
+                label: Array.from({length: 24}, function(_, i) { return 'n' + i; }),
+                pad: 30,
+                thickness: 10
+            },
+            link: {
+                source: Array.from({length: 23}, function(_, i) { return i; }),
+                target: Array.from({length: 23}, function(_, i) { return i + 1; }),
+                value: Array.from({length: 23}, function() { return 1; })
+            }
+        }];
+
+        it('warns when the figure is too small for node.pad', function(done) {
+            var warnings = [];
+            spyOn(Lib, 'warn').and.callFake(function(msg) {
+                warnings.push(msg);
+            });
+
+            var gd = createGraphDiv('pad-warn-small', 300, 100);
+            Plotly.newPlot(gd, Lib.extendDeep([], padMock))
+                .then(function() {
+                    expect(warnings.length).toEqual(1);
+                    expect(warnings[0][0]).toBe('node.pad was reduced to ');
+                    expect(warnings[0][1]).toBeLessThan(30);
+                    return Plotly.purge(gd);
+                })
+                .then(function() { destroyGraphDiv(gd); })
+                .then(done, done.fail);
+        });
+
+        it('does not warn when the figure fits node.pad', function(done) {
+            var warnings = [];
+            spyOn(Lib, 'warn').and.callFake(function(msg) {
+                warnings.push(msg);
+            });
+
+            var gd = createGraphDiv('pad-warn-large', 700, 900);
+            Plotly.newPlot(gd, Lib.extendDeep([], padMock))
+                .then(function() {
+                    expect(warnings.length).toEqual(0);
+                    return Plotly.purge(gd);
+                })
+                .then(function() { destroyGraphDiv(gd); })
+                .then(done, done.fail);
+        });
+    });
+
     describe('sankey global defaults', function() {
         it('should not coerce trace opacity', function() {
             var gd = Lib.extendDeep({}, mock);