From 01b19b8fc5e2263c08193f65cc6d675810ab78e9 Mon Sep 17 00:00:00 2001 From: wanxiankai Date: Tue, 10 Nov 2026 08:14:25 +0800 Subject: [PATCH] fix: resume useThrottle after Strict Mode effect replay --- docs/useThrottle.md | 4 +- src/useThrottle.ts | 2 + stories/useThrottle.story.tsx | 7 +- tests/useThrottle.test.ts | 142 +++++++++++++++++++++++++++++++++- 4 files changed, 152 insertions(+), 3 deletions(-) diff --git a/docs/useThrottle.md b/docs/useThrottle.md index 7557cee256..a0a4b6ded2 100644 --- a/docs/useThrottle.md +++ b/docs/useThrottle.md @@ -2,13 +2,15 @@ React hooks that throttle. +`useThrottle` keeps publishing values when effects are replayed in React Strict Mode. + ## Usage ```jsx import React, { useState } from 'react'; import { useThrottle, useThrottleFn } from 'react-use'; -const Demo = ({value}) => { +const Demo = ({ value }) => { const throttledValue = useThrottle(value); // const throttledValue = useThrottleFn(value => value, 200, [value]); diff --git a/src/useThrottle.ts b/src/useThrottle.ts index b231ba626d..64d161cd03 100644 --- a/src/useThrottle.ts +++ b/src/useThrottle.ts @@ -28,6 +28,8 @@ const useThrottle = (value: T, ms: number = 200) => { useUnmount(() => { timeout.current && clearTimeout(timeout.current); + timeout.current = undefined; + hasNextValue.current = false; }); return state; diff --git a/stories/useThrottle.story.tsx b/stories/useThrottle.story.tsx index b005eb370d..e55e2d6624 100644 --- a/stories/useThrottle.story.tsx +++ b/stories/useThrottle.story.tsx @@ -37,4 +37,9 @@ const Demo = () => { storiesOf('Side effects/useThrottle', module) .add('Docs', () => ) - .add('Demo', () => ); + .add('Demo', () => ) + .add('Strict Mode', () => ( + + + + )); diff --git a/tests/useThrottle.test.ts b/tests/useThrottle.test.ts index 6b4128a0d9..c7fff497dd 100644 --- a/tests/useThrottle.test.ts +++ b/tests/useThrottle.test.ts @@ -1,6 +1,42 @@ -import { renderHook } from '@testing-library/react-hooks'; +import React from 'react'; +import { act, renderHook } from '@testing-library/react-hooks'; import useThrottle from '../src/useThrottle'; +const renderWithEffectReplay = () => { + const originalEffect = React.useEffect; + const effects: React.EffectCallback[] = []; + let cleanups: ReturnType[] = []; + let effectIndex = 0; + + jest.spyOn(React, 'useEffect').mockImplementation((effect, dependencies) => { + const index = effectIndex++; + effects[index] = effect; + originalEffect(() => { + const cleanup = effect(); + cleanups[index] = cleanup; + return cleanup; + }, dependencies); + }); + + const hook = renderHook( + (value) => { + effectIndex = 0; + return useThrottle(value, 100); + }, + { initialProps: 0 } + ); + + return { + ...hook, + replayEffects: () => { + act(() => { + cleanups.forEach((cleanup) => cleanup && cleanup()); + cleanups = effects.map((effect) => effect()); + }); + }, + }; +}; + describe('useThrottle', () => { beforeAll(() => { jest.useFakeTimers(); @@ -8,6 +44,7 @@ describe('useThrottle', () => { afterEach(() => { jest.clearAllTimers(); + jest.restoreAllMocks(); }); afterAll(() => { @@ -72,4 +109,107 @@ describe('useThrottle', () => { jest.advanceTimersByTime(100); expect(hook.result.current).toBe(0); }); + + it('should publish the latest pending value in each throttle interval', () => { + const { result, rerender } = renderHook((value) => useThrottle(value, 100), { + initialProps: 0, + }); + + rerender(1); + rerender(2); + act(() => { + jest.advanceTimersByTime(100); + }); + expect(result.current).toBe(2); + + rerender(3); + rerender(4); + act(() => { + jest.advanceTimersByTime(100); + }); + expect(result.current).toBe(4); + act(() => { + jest.advanceTimersByTime(100); + }); + expect(jest.getTimerCount()).toBe(0); + + rerender(5); + expect(result.current).toBe(5); + }); + + it('should restart the timeout after effect cleanup and setup are replayed', () => { + const { result, rerender, replayEffects } = renderWithEffectReplay(); + + replayEffects(); + expect(jest.getTimerCount()).toBe(1); + rerender(1); + expect(result.current).toBe(0); + act(() => { + jest.advanceTimersByTime(100); + }); + expect(result.current).toBe(1); + + rerender(2); + act(() => { + jest.advanceTimersByTime(100); + }); + expect(result.current).toBe(2); + }); + + it('should discard pending values when effects are replayed', () => { + const { result, rerender, replayEffects } = renderWithEffectReplay(); + + rerender(1); + replayEffects(); + expect(result.current).toBe(1); + expect(jest.getTimerCount()).toBe(1); + + act(() => { + jest.advanceTimersByTime(100); + }); + expect(result.current).toBe(1); + expect(jest.getTimerCount()).toBe(0); + + rerender(2); + expect(result.current).toBe(2); + }); + + it('should keep a single timeout across repeated effect replays', () => { + const { result, rerender, replayEffects, unmount } = renderWithEffectReplay(); + + replayEffects(); + replayEffects(); + replayEffects(); + expect(jest.getTimerCount()).toBe(1); + + rerender(1); + act(() => { + jest.advanceTimersByTime(100); + }); + expect(result.current).toBe(1); + + unmount(); + expect(jest.getTimerCount()).toBe(0); + }); + + it('should replay idle effects and clean up without an active timeout', () => { + const { result, rerender, replayEffects, unmount } = renderWithEffectReplay(); + + act(() => { + jest.advanceTimersByTime(100); + }); + expect(jest.getTimerCount()).toBe(0); + + replayEffects(); + expect(jest.getTimerCount()).toBe(1); + rerender(1); + act(() => { + jest.advanceTimersByTime(200); + }); + expect(result.current).toBe(1); + expect(jest.getTimerCount()).toBe(0); + + unmount(); + expect(jest.getTimerCount()).toBe(0); + }); });