fix(useInterval): prevent immediate callback from refiring when enabled is toggled

[eunwoo-levi]

Overview

useInterval with immediate: true re-fires the callback every time enabled goes from false to true, even though it should only fire once when the interval first starts.

Root Cause

enabled is included in the immediate effect's dependency array, so the effect re-runs on every enabled change.

useEffect(() => {
    if (immediate === true && enabled) {                                                    
      preservedCallback(); // fires again on every re-enable
    }                                                                                       
}, [immediate, preservedCallback, enabled]); // enabled triggers re-run

Fix

Added immediateCalledRef to ensure the callback fires only once per interval lifecycle.

const immediateCalledRef = useRef(false);                                                 
                
useEffect(function callImmediately() {
  if (immediate !== true || !enabled || immediateCalledRef.current) {
    return;                                                                               
  }
  immediateCalledRef.current = true;                                                      
  preservedCallback();
}, [immediate, preservedCallback, enabled]);   

Checklist

• Did you write the test code?
• Have you run yarn run fix to format and lint the code and docs?
• Have you run yarn run test:coverage to make sure there is no uncovered line?
• Did you write the JSDoc?

[Copilot]

Pull request overview

Fixes useInterval’s immediate: true behavior so the callback does not run again when enabled is toggled from false back to true.

Changes:

• Add an immediateCalledRef guard so the “immediate” callback runs only once.
• Add a regression test covering enabled toggling with immediate: true.
• Add a patch changeset for release notes/versioning.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 1 comment.

File	Description
packages/core/src/hooks/useInterval/useInterval.ts	Adds a ref-based guard to prevent immediate callback re-firing on enabled toggles.
packages/core/src/hooks/useInterval/useInterval.spec.ts	Adds a test ensuring immediate callback does not re-fire after disabling/re-enabling.
.changeset/lovely-spies-change.md	Declares a patch release note for the fix.