fix(dataZoom): keep neighbor rows when filtering line series so partial segments and null gaps survive. close #21564, close #21565

When dataZoom uses the default filterMode 'filter', AxisProxy calls
selectRange() on the series store, which physically drops every row
whose value falls outside the window. For line / area series this
corrupts the rendering in two ways:

  - A line segment that crosses the window boundary loses one of its
    endpoints, so the visible portion of the segment vanishes
    entirely (#21564).
  - A null data point that interrupts the line gets dropped if its
    own value sits outside the window, so the line view no longer
    sees the gap and connects across it as a ghost line (#21565).
    This is most visible when data is non-monotonic in the filter
    dimension and the null is the only signal that two adjacent rows
    belong to different segments.

Replace selectRange with a boundary-aware filter for line subType
only: keep row i when row i, row i-1 or row i+1 is in the window.
A single Uint8Array pre-scan computes inWindow status; filterSelf
then applies the keep predicate. Other series types and other filter
modes are untouched.

Adds unit coverage for the partial-segment case, the null-gap case,
the bar-series no-op, the filterMode: 'none' no-op, and the
all-in-window short-circuit. Adds a visual reproducer at
test/line-dataZoom-boundary.html.

Author: JamesGoslings

src/component/dataZoom/AxisProxy.ts

@@ -450,6 +450,13 @@ class AxisProxy {
                             })
                         );
                     }
+                    else if (shouldKeepLineBoundary(seriesModel)) {
+                        // Line / area series need one neighboring data row on each side
+                        // of the in-window range so partial line segments at the
+                        // boundary are still drawn (#21564) and null gap markers that
+                        // fall outside the window still interrupt the line (#21565).
+                        keepLineBoundary(seriesData, dim, valueWindow);
+                    }
                     else {
                         const range: Dictionary<[number, number]> = {};
                         range[dim] = valueWindow as [number, number];
@@ -499,4 +506,45 @@ class AxisProxy {
     }
 }
 
+function shouldKeepLineBoundary(seriesModel: SeriesModel): boolean {
+    return seriesModel.subType === 'line';
+}
+
+function keepLineBoundary(
+    seriesData: ReturnType<SeriesModel['getData']>,
+    dim: string,
+    valueWindow: number[]
+): void {
+    const store = seriesData.getStore();
+    const dimIdx = seriesData.getDimensionIndex(dim);
+    const count = store.count();
+    if (!count || dimIdx < 0) {
+        return;
+    }
+
+    const min = valueWindow[0];
+    const max = valueWindow[1];
+    const inWindow = new Uint8Array(count);
+    let allIn = true;
+    for (let i = 0; i < count; i++) {
+        const v = store.get(dimIdx, i) as number;
+        const isIn = ((v >= min && v <= max) || isNaN(v)) ? 1 : 0;
+        inWindow[i] = isIn;
+        if (!isIn) {
+            allIn = false;
+        }
+    }
+    if (allIn) {
+        return;
+    }
+
+    seriesData.filterSelf(function (idx: number) {
+        return !!(
+            inWindow[idx]
+            || (idx > 0 && inWindow[idx - 1])
+            || (idx < count - 1 && inWindow[idx + 1])
+        );
+    });
+}
+
 export default AxisProxy;