From 1927b0e645d5621e7623632265e2c175f71d9da4 Mon Sep 17 00:00:00 2001 From: Aaron_Zhou Date: Mon, 9 Nov 2026 18:57:40 +0800 Subject: [PATCH 1/2] fix: handle picker blur after Activity hides --- src/PickerInput/RangePicker.tsx | 3 ++- src/PickerInput/SinglePicker.tsx | 3 ++- tests/blur.spec.tsx | 45 ++++++++++++++++++++++++++++++++ 3 files changed, 49 insertions(+), 2 deletions(-) diff --git a/src/PickerInput/RangePicker.tsx b/src/PickerInput/RangePicker.tsx index 14809c4d3..3ff15ae50 100644 --- a/src/PickerInput/RangePicker.tsx +++ b/src/PickerInput/RangePicker.tsx @@ -272,8 +272,9 @@ function RangePicker( const calendarValue = getCalendarValue(); // ======================== Focus ========================= + // Activity may detach the selector ref before a pending blur event is handled. const isInternalPickerElement = useEvent((element: EventTarget | null) => - isTargetInContainers(element, [selectorRef.current.nativeElement, popupRef.current]), + isTargetInContainers(element, [selectorRef.current?.nativeElement, popupRef.current]), ); const [focused, onFieldFocus, onFieldBlur] = useFocusEvents( diff --git a/src/PickerInput/SinglePicker.tsx b/src/PickerInput/SinglePicker.tsx index 05163879f..b3c7484fe 100644 --- a/src/PickerInput/SinglePicker.tsx +++ b/src/PickerInput/SinglePicker.tsx @@ -256,8 +256,9 @@ function Picker( const calendarValue = getCalendarValue(); // ======================== Focus ========================= + // Activity may detach the selector ref before a pending blur event is handled. const isInternalPickerElement = useEvent((element: EventTarget | null) => - isTargetInContainers(element, [selectorRef.current.nativeElement, popupRef.current]), + isTargetInContainers(element, [selectorRef.current?.nativeElement, popupRef.current]), ); const [focused, onFieldFocus, onFieldBlur] = useFocusEvents( diff --git a/tests/blur.spec.tsx b/tests/blur.spec.tsx index 6bf027a42..0f2d2a9ed 100644 --- a/tests/blur.spec.tsx +++ b/tests/blur.spec.tsx @@ -65,3 +65,48 @@ describe('Picker.ChangeOnBlur', () => { expect(endInputEle).toHaveValue('no valid 2'); }); }); + +describe.each([ + ['Picker', DayPicker, 0], + ['RangePicker start', DayRangePicker, 0], + ['RangePicker end', DayRangePicker, 1], +] as const)('%s with Activity', (_name, Picker, inputIndex) => { + beforeEach(() => { + jest.useFakeTimers(); + }); + + afterEach(() => { + jest.clearAllTimers(); + jest.useRealTimers(); + }); + + it.each(['outside', 'null'])( + 'handles a delayed blur to %s after hiding and can reopen after restoring', + async (target) => { + const onBlur = jest.fn(); + const onOpenChange = jest.fn(); + const renderPicker = (mode: 'visible' | 'hidden') => ( + + + + ); + const { container, rerender } = render(renderPicker('visible')); + const input = container.querySelectorAll('input')[inputIndex]; + + openPicker(container, inputIndex); + expect(onOpenChange).toHaveBeenLastCalledWith(true); + + rerender(renderPicker('hidden')); + // A native blur can arrive after Activity has detached the selector ref. + fireEvent.blur(input, { relatedTarget: target === 'outside' ? document.body : null }); + await waitFakeTimer(); + expect(onBlur).toHaveBeenCalledTimes(1); + expect(onOpenChange).toHaveBeenLastCalledWith(false); + + rerender(renderPicker('visible')); + expect(container.querySelectorAll('input')[inputIndex]).toBe(input); + openPicker(container, inputIndex); + expect(onOpenChange).toHaveBeenLastCalledWith(true); + }, + ); +}); From ee8426dcb0b56c695fca5020e31860f700404547 Mon Sep 17 00:00:00 2001 From: Aaron_Zhou Date: Tue, 10 Nov 2026 12:14:22 +0800 Subject: [PATCH 2/2] fix: handle time scrolling across Activity transitions --- .../TimePanel/TimePanelBody/TimeColumn.tsx | 3 +- .../TimePanel/TimePanelBody/useScrollTo.ts | 3 + tests/activity-scroll.spec.tsx | 106 ++++++++++++++++++ 3 files changed, 111 insertions(+), 1 deletion(-) create mode 100644 tests/activity-scroll.spec.tsx diff --git a/src/PickerPanel/TimePanel/TimePanelBody/TimeColumn.tsx b/src/PickerPanel/TimePanel/TimePanelBody/TimeColumn.tsx index 8f8b7497a..6f5d452dd 100644 --- a/src/PickerPanel/TimePanel/TimePanelBody/TimeColumn.tsx +++ b/src/PickerPanel/TimePanel/TimePanelBody/TimeColumn.tsx @@ -113,7 +113,8 @@ export default function TimeColumn(props: TimeUnitColum const target = event.target as HTMLUListElement; - if (!isScrolling() && changeOnScroll) { + // Activity may deliver a queued native scroll after detaching the column ref. + if (ulRef.current && !isScrolling() && changeOnScroll) { checkDelayRef.current = setTimeout(() => { const ul = ulRef.current!; const firstLiTop = ul.querySelector(`li`).offsetTop; diff --git a/src/PickerPanel/TimePanel/TimePanelBody/useScrollTo.ts b/src/PickerPanel/TimePanel/TimePanelBody/useScrollTo.ts index 005a89d85..2f528635a 100644 --- a/src/PickerPanel/TimePanel/TimePanelBody/useScrollTo.ts +++ b/src/PickerPanel/TimePanel/TimePanelBody/useScrollTo.ts @@ -45,6 +45,9 @@ export default function useScrollTo( if ((targetLiTop === 0 && targetLi !== firstLi) || !isVisible(ul)) { if (scrollRafTimesRef.current <= 5) { scrollRafRef.current = raf(doScroll); + } else { + // Reconnecting with a hidden popup must not leave user scrolling locked. + stopScroll(); } return; } diff --git a/tests/activity-scroll.spec.tsx b/tests/activity-scroll.spec.tsx new file mode 100644 index 000000000..484365033 --- /dev/null +++ b/tests/activity-scroll.spec.tsx @@ -0,0 +1,106 @@ +import { fireEvent, render } from '@testing-library/react'; +import { isVisible, spyElementPrototype } from '@rc-component/util'; +import React from 'react'; +import { DayPicker, DayRangePicker, getDay, openPicker, waitFakeTimer } from './util/commonUtil'; + +jest.mock('@rc-component/util/lib/Dom/isVisible', () => { + return jest.fn(() => true); +}); + +describe.each([false, true])('Activity time scrolling (range=%s)', (range) => { + let offsetTopMock: ReturnType; + + beforeEach(() => { + jest.mocked(isVisible).mockReturnValue(true); + jest.useFakeTimers().setSystemTime(getDay('1990-09-03 00:00:00').valueOf()); + offsetTopMock = spyElementPrototype(HTMLLIElement, 'offsetTop', { + get() { + const children = Array.from(this.parentNode?.childNodes || []); + return children.indexOf(this) * 30; + }, + }); + }); + + afterEach(() => { + offsetTopMock.mockRestore(); + jest.clearAllTimers(); + jest.useRealTimers(); + }); + + describe.each(['before', 'after'])('scroll arrives %s hiding', (scrollTiming) => { + it.each([ + { restore: 'before the delay', beforeDelay: true, popupHidden: false }, + { restore: 'after the delay', beforeDelay: false, popupHidden: false }, + { restore: 'before the delay with a closed popup', beforeDelay: true, popupHidden: true }, + ])( + 'preserves the value when restored $restore and allows new scrolling', + async ({ beforeDelay, popupHidden }) => { + const onCalendarChange = jest.fn(); + const initialValue = getDay('1990-09-03 00:00:00'); + const view = (mode: 'visible' | 'hidden') => ( + + + {range ? ( + + ) : ( + + )} + + + ); + const { container, rerender } = render(view('visible')); + const input = container.querySelector('input'); + openPicker(container); + await waitFakeTimer(); + onCalendarChange.mockClear(); + const column = document.querySelector('.rc-picker-time-panel-column'); + const scroll = () => fireEvent.scroll(column, { target: { scrollTop: 30 } }); + + if (scrollTiming === 'before') { + scroll(); + } + rerender(view('hidden')); + if (scrollTiming === 'after') { + // Browsers may deliver a queued native scroll after Activity cleanup. + scroll(); + } + if (beforeDelay) { + if (popupHidden) { + // A closed popup is still hidden when Activity reconnects its effects. + jest.mocked(isVisible).mockReturnValue(false); + } + rerender(view('visible')); + } + await waitFakeTimer(); + expect(onCalendarChange).not.toHaveBeenCalled(); + expect(input).toHaveValue('00:00:00'); + + jest.mocked(isVisible).mockReturnValue(true); + rerender(view('visible')); + expect(container.querySelector('input')).toBe(input); + openPicker(container); + await waitFakeTimer(); + onCalendarChange.mockClear(); + fireEvent.scroll(document.querySelector('.rc-picker-time-panel-column'), { + target: { scrollTop: 60 }, + }); + await waitFakeTimer(); + expect(onCalendarChange).toHaveBeenCalledTimes(1); + expect(onCalendarChange.mock.calls[0][1]).toEqual( + range ? ['02:00:00', '00:00:00'] : '02:00:00', + ); + expect(input).toHaveValue('02:00:00'); + }, + ); + }); +});