Skip to content

An open source design system that's fully customizable and agent ready

TypeScript

fix(Slider): hold the lost-capture document listener only during a drag (#8284)

Cindy Zhangbf806901b00c
diff --git a/.changeset/slider-lost-capture-drag-scope.md b/.changeset/slider-lost-capture-drag-scope.md
new file mode 100644
index 0000000000..e54a1dc64d
--- /dev/null
+++ b/.changeset/slider-lost-capture-drag-scope.md
@@ -0,0 +1,7 @@
+---
+'@astryxdesign/core': patch
+---
+
+[fix] Slider: the document listener that ends a drag when its pointer capture is lost now exists only while a drag is in progress, so an idle slider no longer holds a document-level listener for its whole lifetime. A drag still ends when the control is replaced mid-drag (a FormLayout direction change).
+
+@cixzhang
diff --git a/packages/core/src/Slider/Slider.test.tsx b/packages/core/src/Slider/Slider.test.tsx
index 32ebd2b421..8fac0f7856 100644
--- a/packages/core/src/Slider/Slider.test.tsx
+++ b/packages/core/src/Slider/Slider.test.tsx
@@ -1421,7 +1421,11 @@ describe('one pointer per drag', () => {
// replacing the control node while the drag holds it. The browser then
// fires lostpointercapture at the document, not at the removed node.
const onChangeEnd = vi.fn();
- function InLayout({direction}: {direction: 'vertical' | 'horizontal'}) {
+ function InLayout({
+ direction,
+ }: {
+ direction: 'vertical' | 'horizontal-labels';
+ }) {
return (
<FormLayout direction={direction}>
<ControlledSlider id="Volume" onChangeEnd={onChangeEnd} />
@@ -1432,7 +1436,7 @@ describe('one pointer per drag', () => {
const before = trackOf(screen.getByRole('slider'));
fireEvent.pointerDown(before, {clientX: 136, clientY: 10, pointerId: 1});
- rerender(<InLayout direction="horizontal" />);
+ rerender(<InLayout direction="horizontal-labels" />);
fireEvent.lostPointerCapture(document, {pointerId: 1});
expect(onChangeEnd).toHaveBeenCalledOnce();
@@ -1443,6 +1447,31 @@ describe('one pointer per drag', () => {
expect(thumb).toHaveAttribute('aria-valuenow', '10');
});
+ it('holds a document listener only while a drag is in progress', () => {
+ const add = vi.spyOn(document, 'addEventListener');
+ const remove = vi.spyOn(document, 'removeEventListener');
+ const lostCapture = (spy: typeof add) =>
+ spy.mock.calls.filter(([type]) => type === 'lostpointercapture');
+ const {unmount} = render(<ControlledSlider id="Volume" />);
+ const track = trackOf(screen.getByRole('slider'));
+ // Idle: no document listener.
+ expect(lostCapture(add)).toHaveLength(0);
+
+ fireEvent.pointerDown(track, {clientX: 136, clientY: 10, pointerId: 1});
+ expect(lostCapture(add)).toHaveLength(1);
+ const listener = lostCapture(add)[0][1];
+ fireEvent.pointerUp(track, {clientX: 136, clientY: 10, pointerId: 1});
+ expect(lostCapture(remove).map(([, fn]) => fn)).toEqual([listener]);
+
+ // A slider unmounted mid-drag removes its listener too.
+ fireEvent.pointerDown(track, {clientX: 28, clientY: 10, pointerId: 2});
+ const second = lostCapture(add)[1][1];
+ unmount();
+ expect(lostCapture(remove).map(([, fn]) => fn)).toEqual([listener, second]);
+ add.mockRestore();
+ remove.mockRestore();
+ });
+
it('lets two fingers drag two sliders at once', () => {
render(
<>
diff --git a/packages/core/src/Slider/Slider.tsx b/packages/core/src/Slider/Slider.tsx
index aad4b7d6fc..921c30ea8c 100644
--- a/packages/core/src/Slider/Slider.tsx
+++ b/packages/core/src/Slider/Slider.tsx
@@ -743,6 +743,31 @@ export function Slider({ref, ...props}: SliderProps) {
// drag the first one owns.
const dragPointerRef = useRef<number | null>(null);
+ // Removes the document lostpointercapture listener of the drag in progress.
+ // It exists only while a drag does, so an idle slider holds no document
+ // listener (react-component-runtime INV5).
+ const detachLostCaptureRef = useRef<(() => void) | null>(null);
+
+ const endDrag = useCallback(
+ (pointerId: number) => {
+ if (
+ draggingThumbRef.current !== null &&
+ pointerId === dragPointerRef.current
+ ) {
+ detachLostCaptureRef.current?.();
+ detachLostCaptureRef.current = null;
+ draggingThumbRef.current = null;
+ dragPointerRef.current = null;
+ setDraggingThumb(null);
+ fireChangeEnd();
+ }
+ },
+ [fireChangeEnd],
+ );
+
+ // A slider unmounted mid-drag leaves no listener behind.
+ useEffect(() => () => detachLostCaptureRef.current?.(), []);
+
const handlePointerDown = useCallback(
(e: PointerEvent<HTMLDivElement>) => {
if (isDisabled) {
@@ -787,13 +812,27 @@ export function Slider({ref, ...props}: SliderProps) {
// through the drag.
setKeyboardFocusThumb(null);
+ // A capture lost without an up or a cancel (the browser releases it, or
+ // script does) still ends the drag, so the slider never stays held by a
+ // pointer that is gone. The listener sits on the document, where
+ // lostpointercapture bubbles to and where the browser fires it when the
+ // captured node is removed, so a control node replaced during the drag
+ // (a FormLayout direction change) is still covered. It lives only for
+ // this drag.
+ const doc = (e.currentTarget as HTMLElement).ownerDocument;
+ const onLostCapture = (event: globalThis.PointerEvent) =>
+ endDrag(event.pointerId);
+ doc.addEventListener('lostpointercapture', onLostCapture);
+ detachLostCaptureRef.current = () =>
+ doc.removeEventListener('lostpointercapture', onLostCapture);
+
if (
typeof (e.currentTarget as HTMLElement).setPointerCapture === 'function'
) {
(e.currentTarget as HTMLElement).setPointerCapture(e.pointerId);
}
},
- [isDisabled, getValueFromPosition, getClosestThumb, updateValue],
+ [isDisabled, getValueFromPosition, getClosestThumb, updateValue, endDrag],
);
const handlePointerMove = useCallback(
@@ -811,43 +850,11 @@ export function Slider({ref, ...props}: SliderProps) {
[isDisabled, getValueFromPosition, updateValue],
);
- const endDrag = useCallback(
- (pointerId: number) => {
- if (
- draggingThumbRef.current !== null &&
- pointerId === dragPointerRef.current
- ) {
- draggingThumbRef.current = null;
- dragPointerRef.current = null;
- setDraggingThumb(null);
- fireChangeEnd();
- }
- },
- [fireChangeEnd],
- );
-
const handlePointerUp = useCallback(
(e: PointerEvent<HTMLDivElement>) => endDrag(e.pointerId),
[endDrag],
);
- // A capture lost without an up or a cancel (the browser releases it, or
- // script does) still ends the drag, so the slider never stays held by a
- // pointer that is gone and keeps answering new presses. The listener sits
- // on the document, where lostpointercapture bubbles to and where the browser
- // fires it when the captured node is removed, so a control node replaced
- // before or during a drag (a FormLayout direction change) is still covered.
- useEffect(() => {
- const doc = trackRef.current?.ownerDocument;
- if (doc == null) {
- return;
- }
- const onLostCapture = (event: globalThis.PointerEvent) =>
- endDrag(event.pointerId);
- doc.addEventListener('lostpointercapture', onLostCapture);
- return () => doc.removeEventListener('lostpointercapture', onLostCapture);
- }, [endDrag]);
-
// Keyboard handler
const handleKeyDown = useCallback(
(thumbIndex: number, e: KeyboardEvent<HTMLDivElement>) => {