Context Value Objects and Referential Stability
You'll learn why Context provider values need useMemo to avoid triggering all consumers on every render of the provider component.
The Problem with Inline Objects
When you create a Context provider, you typically pass a value object containing state and functions. If you create this object inline during render, React sees it as a brand new object every time — even if the contents are identical. Since Context consumers check referential equality, they all re-render unnecessarily.
// ❌ Bad: New object reference on every render
<UserContext.Provider value={{ user, setUser }}>
{children}
</UserContext.Provider>
Every time the provider component renders (for any reason), that { user, setUser } creates a fresh object. All consumers detect a "change" and re-render, even if user hasn't actually changed.
The Solution: useMemo
Wrap the value object in useMemo to maintain referential stability:
// ✅ Good: Stable reference unless dependencies change
const value = useMemo(() => ({ user, setUser }), [user]);
<UserContext.Provider value={value}>
{children}
</UserContext.Provider>
Now the object reference only changes when user changes. The setUser function is already stable (setState setters never change), so it doesn't need to be in the dependency array.
Why This Matters
Without useMemo, a single state change in your provider component (like an unrelated loading flag) would cause every single consumer across your entire component tree to re-render. With useMemo, consumers only re-render when the actual Context data changes.
Key Takeaway: Always wrap Context provider value objects in useMemo with appropriate dependencies to prevent unnecessary consumer re-renders caused by referential instability.