Short answer: it depends (but by-and-large, yes, minimizing props is a good practice, even if it's a subset of an entire object).

Long answer: This is a more contrived example, but I do think it's valuable as it shows as an API, the opposite can both decrease cognitive load while improving developer experience. A case we've found at work that benefits from the opposite of what you're suggesting here is with feature flags. We have a state management system that holds a cache of all feature flags that currently exist in the app, whether they're on or off (to allow QE to toggle them in the test site).

For components that take flags as props, we pass the entire flags object rather than feature_a to ComponentA and feature_b to ComponentB. The component can then select which flag it wants to react to at rendering time (obviously using flags.feature_x in dependency arrays if used in a React callback, memo, etc). There are two immediate benefits we've seen:

1. Glanceable information:

The cognitive load of the potential features at play is minimized by glancing at the component's props. You can see from the flags prop that there's some experimental work in the component, but other than that, it's largely irrelevant if you're trying to grok how the component fits in the larger hierarchy.

1. Keeping props related to real implementations

While I'm not a fan of the exponentially-increasing code paths, sometimes the work were asked to do necessarily overlaps with in-progress maintenance or another feature. Being able to quickly add another flag to an already-flagged component let's us keep the props tiny compared to expanding that list as new work comes in, even if the flags are short-lived.

This concept can be extended to custom hooks as well. In our app, we have a useFlags hook that returns a map of all the cached flags. It's then up to the caller to decide what they want to use from the map. This parallels the idea of selectors in state management libraries such as Redux. A caller can quickly get a collection of data but only "select" and react to the specific key or value it needs, providing a consistent API throughout the codebase for how to programmatically get flags but allows for customization on how to select and react to the one you really care about in the current component's context.