Port remaining hooks from react-use

[JoeDuncko]

Our goal with @react-hookz/web is to give the react community a general-purpose React hooks library built with care.

We'd like to port the remaining hooks from react-use (the project @react-hookz/web grew out of) while keeping in mind our tenants:

• General-purposeness (hooks should fulfill a wide array of use cases)
• Composability (a preference for hooks that are useful for building other hooks)
• No or very few dependencies
• SSR compatibility
• 100% test coverage (ideally)
• Concrete example use cases

Hooks to port

Sensors

• useBattery — tracks device battery state.
• useGeolocation — tracks geo location state of user's device.
• useHover — tracks mouse hover state of some element.
• useHoverDirty — tracks mouse hover state of some element.
• useHash — tracks location hash value. (No plans to implement. Instead, use one the various routing libraries available.)
• useIdle — tracks whether user is being inactive.
• useIntersection — tracks an HTML element's intersection. (Implemented as useIntersectionObserver)
• useKey — track keys. (Implemented as useKeyboardEvent)
• useKeyPress — track keys. (Implemented as useKeyboardEvent)
• useKeyboardJs — track keys. (Implemented as useKeyboardEvent)
• useKeyPressEvent — track keys. (Implemented as useKeyboardEvent)
• useLocation — tracks page navigation bar location state. (No plans to implement. Instead, use one the various routing libraries available.)
• useSearchParam — tracks page navigation bar location state. (No plans to implement. Instead, use one the various routing libraries available.)
• useLongPress — tracks long press gesture of some element.
• useMedia — tracks state of a CSS media query. (implemented as useMediaQuery)
• useMediaDevices — tracks state of connected hardware devices.
• useMotion — tracks state of device's motion sensor.
• useMouse — tracks state of mouse position.
• useMouseHovered — tracks state of mouse position.
• useMouseWheel — tracks deltaY of scrolled mouse wheel.
• useNetworkState — tracks the state of browser's network connection. (implemented as useNetwork)
• useOrientation — tracks state of device's screen orientation.
• usePageLeave — triggers when mouse leaves page boundaries.
• useScratch — tracks mouse click-and-scrub state.
• useScroll — tracks an HTML element's scroll position.
• useScrolling — tracks whether HTML element is scrolling.
• useStartTyping — detects when user starts typing.
• useWindowScroll — tracks Window scroll position.
• useWindowSize — tracks Window dimensions.
• useMeasure — tracks an HTML element's dimensions. (implemented as useMeasure)
• useSize — tracks an HTML element's dimensions. (Use useWindowSize instead)
• createBreakpoint — tracks innerWidth (Not planning to implement)
• useScrollbarWidth — detects browser's native scrollbars width.

UI

• useAudio — plays audio and exposes its controls.
• useClickAway — triggers callback when user clicks outside target area. (Implmented as useClickOutside)
• useCss — dynamically adjusts CSS.
• useDrop — tracks file, link and copy-paste drops.
• useDropArea — tracks file, link and copy-paste drops.
• useFullscreen — display an element or video full-screen.
• useSlider — provides slide behavior over any HTML element.
• useSpeech — synthesizes speech from a text string.
• useVibrate — provide physical feedback using the Vibration API.
• useVideo — plays video, tracks its state, and exposes playback controls.

Animations

• useRaf — re-renders component on each requestAnimationFrame.
• useInterval and useHarmonicIntervalFn — re-renders component on a set interval using setInterval. (Implemented as useIntervalEffect).
• useSpring — interpolates number over time according to spring dynamics.
• useTimeout — re-renders component after a timeout. (Can be composed from other hooks, see migration guide).
• useTimeoutFn — calls given function after a timeout. (Implemented as useTimeoutEffect).
• useTween — re-renders component, while tweening a number from 0 to 1.
• useUpdate — returns a callback, which re-renders component when called. (Implemented as useRerender)

Side-effects

• useAsync — resolves an async function. (implemented as useAsync)
• useAsyncFn — resolves an async function. (implemented as useAsync)
• useAsyncRetry — resolves an async function. (implemented as useAsync)
• useBeforeUnload — shows browser alert when user try to reload or close the page. (No plans to implement, address migration guide for workaround)
• useCookie — provides way to read, update and delete a cookie. (implemented as useCookieValue)
• useCopyToClipboard — copies text to clipboard. (no plans to implement - use browser's API instead)
• useDebounce — debounces a function. (Implemented as useDebounceCallback)
• useError — error dispatcher.
• useFavicon — sets favicon of the page. (Hooks that modify the element will not be implemented).
• useLocalStorage — manages a value in localStorage. (Implemented as useLocalStorageValue)
• useLockBodyScroll — lock scrolling of the body element.
• useRafLoop — calls given function inside the RAF loop.
• useSessionStorage — manages a value in sessionStorage. (Implemented as useSessionStorageValue)
• useThrottle — throttles a function.
• useThrottleFn — throttles a function.
• useTitle — sets title of the page. (Hooks that modify the element will not be implemented).
• usePermission — query permission status for browser APIs. (Implemented as usePermission)

Lifecycles

• useEffectOnce — a modified useEffect hook that only runs once. (it's just an alias for useMountEffect)
• useEvent — subscribe to events. (Implemented as useEventListener)
• useLifecycles — calls mount and unmount callbacks. (no sense to port, has almost no benefit comparing to useEffect)
• useMountedState — track if component is mounted. (Implemented as useIsMounted)
• useUnmountPromise — track if component is mounted. (No plans to implement).
• usePromise — resolves promise only while component is mounted. (No plans to implement)
• useLogger — logs in console as component goes through life-cycles. (Implemented as useLifecycleLogger
• useMount — calls mount callbacks. (Implemented as useMountEffect)
• useUnmount — calls unmount callbacks. (Implemented as useUnmountEffect)
• useUpdateEffect — run an effect only on updates. (Implemented as useUpdateEffect)
• useIsomorphicLayoutEffect — useLayoutEffect that does not show warning when server-side rendering. (Implemented as useIsomorphicLayoutEffect)
• useDeepCompareEffect — run an effect depending on deep comparison of its dependencies. (Implemented as useDeepCompareEffect)
• useShallowCompareEffect — run an effect depending on deep comparison of its dependencies
• useCustomCompareEffect — run an effect depending on deep comparison of its dependencies. (Implemented as useCustomCompareEffect)

State

• createMemo — factory of memoized hooks. (Not planning to implement)
• createReducer — factory of reducer hooks with custom middleware. (Not planning to implement)
• createReducerContext — factory of hooks for a sharing state between components. (Not planning to implement)
• createStateContext — factory of hooks for a sharing state between components. (Not planning to implement)
• useDefault — returns the default value when state is null or undefined. (No plans to implement. Use useMediatedState instead).
• useGetSet — returns state getter get() instead of raw state. (No plans to implement)
• useGetSetState — as if useGetSet and useSetState had a baby. (No plans to implement)
• useLatest — returns the latest state or props (Implemented as useSynchedRef)
• usePrevious — returns the previous state or props. (Implemented as usePrevious)
• usePreviousDistinct — like usePrevious but with a predicate to determine if previous should update. (Implemented as usePreviousDistinct)
• useObservable — tracks latest value of an Observable.
• useRafState — creates setState method which only updates after requestAnimationFrame.
• useSetState — creates setState method which works like this.setState. (No plans to implement)
• useStateList — circularly iterates over an array.
• useToggle — tracks state of a boolean. (Implemented as useToggle)
• useBoolean — tracks state of a boolean. (Implemented as useToggle)
• useCounter — tracks state of a number.
• useNumber — tracks state of a number. (Implemented as useCounter)
• useList — tracks state of an array.
• useUpsert — tracks state of an array. (Use useList instead.)
• useMap — tracks state of an object. (Implemented as useMap)
• useSet — tracks state of a Set. (Implemented as useSet)
• useQueue — implements simple queue. (Implemented as useQueue)
• useStateValidator — tracks state of an object.
• useStateWithHistory — stores previous state values and provides handles to travel through them.
• useMultiStateValidator — alike the useStateValidator, but tracks multiple states at a time.
• useMediatedState — like the regular useState but with mediation by custom function. (Implemented as useMediatedState)
• useFirstMountState — check if current render is first. (Implemented as useFirstMountState)
• useRendersCount — count component renders. (Implemented as useRenderCount).
• createGlobalState — cross component shared state. (Not planning to implement)
• useMethods — neat alternative to useReducer. (No plans to implement)

Miscellaneous

• useEnsuredForwardedRef — use a React.forwardedRef safely.
• ensuredForwardRef — use a React.forwardedRef safely.

Join our community!

Have a question? Create a discussion on GitHub or join our Discord community.

Interested in contributing code? Check out our contribution guide. We are excited to see your pull request!

[xobotyi]

To be clear - not all hooks will be ported, as for me - i'm against of transfering all create* hooks. And its not the only example.

[JoeDuncko]

To be clear - not all hooks will be ported, as for me - i'm against of transfering all create* hooks. And its not the only example.

Definitely! Should we make a list of all the hooks that we don't want ported? Then I can cross them out above. @xobotyi

[xobotyi]

@JoeDuncko its hard to say rn, im reviewing the hooks on the go and currently refactoring (the full cycle refactoring, meaning reimplementing them from the scratch) hooks im currently using at my job, as this is easiest way for me, as i have little expertise in other areas.

[xobotyi]

useMountedState and useUnmountPromise — track if component is mounted. (Implemented as useIsMounted)

we dont have useUnmountPromise yet

[JoeDuncko]

Crossed out the "create" hooks, split up all the lines with "and"s.

[JoeDuncko]

Added links to the new useIsomorphicLayoutEffect and useDebounceCallback hooks

[axelboc]

Thank you so much for starting this repo and leading this huge migration work! 🍻

Just wondering what the reasoning is for not migrating the create* utilities, and particularly createMemo. In my project, I have a good number of utility functions that loop over very large arrays, so it's important that they are memoised with useMemo. With createMemo I don't have to create hooks with the same signature as the utility functions, so it's really convenient and avoids a lot of duplication (especially since I use TypeScript).

I should add that I can't just turn all of my utility functions into hooks with useMemo inside them, as I use some of them inside loops. I need both the hook and non-hook versions.

[JoeDuncko]

This issue should now be up to date FYI.

[xobotyi]

I can't see the sense of porting useTimeout but useTimeoutCallback would be pretty much handy one, since it could be well composed with other hooks

[jpwallace22]

@xobotyi I was about to do it, but it looks like there is already a useTimeoutEffect that does it. Might want to check the box.

[ArttuOll]

Updated the list again.

[ArttuOll]

Ticked off usePromise, which will not be implemented, as decided in #1048 . Also ticked off useLogger, which has been implemented as useLifecycleLogger and useRendersCount which has been implemented as useRenderCount.

What does everybody think about porting of the following hooks:

• useUnmountPromise - Probably should not be ported, because it's almost the same as usePromise.
• useShallowCompareEffect - We already have useDeepCompareEffect and useCustomCompareEffect. Could be easily implemented.
• useGetSet - Could be useful for some functional programming stuff, but you could easily wrap the state setter into a function yourself (value: A) => setState(value). Also the examples in react-use for this hook make it seem that this hook could be replaced with just functional state updates.
• useSetState - I feel like this hook is unsuitable for modern React (it emulates this.setState of class-based components).
• useMethods - Slight syntactic sugar over useReducer.

[xobotyi]

agreed on all of them

[tansanDOTeth]

For useTween, I would like to make a suggestion to the API. It would be helpful if it can return a start function to grant control over when to start the tweening process.

const [t, start, stop, restart] = useTween()

[Frankcaozas]

@JoeDuncko can i work on useScrolling, only the test is not done

[JoeDuncko]

@JoeDuncko can i work on useScrolling, only the test is not done

Sure!

[malavshah9]

@JoeDuncko I would like to work on useQueue, can I start working on it?

[JoeDuncko]

@JoeDuncko I would like to work on useQueue, can I start working on it?

Sure!

[xobotyi]

@JoeDuncko dang it! we already have a queue hook, but it is missing from hooks listing🤦‍♂️

[JoeDuncko]

@JoeDuncko dang it! we already have a queue hook, but it is missing from hooks listing🤦‍♂️

@xobotyi Ah crap, I can knock that out if no one else does tomorrow.

[malavshah9]

@JoeDuncko @xobotyi
I was just looking to work on useCopyToClipboard, but then found this discussion where we have concluded that it is not needed at the moment. Can we remove this from this list also, if we don't want to build it.

[malavshah9]

@JoeDuncko @xobotyi
Moreover, I am looking to work on useSpeech with the following definition, is this fine or do we want to improve here?

type SpeechOptions = {
  lang: string;
  voice?: SpeechSynthesisVoice;
  rate: number;
  pitch: number;
  volume: number;
};
export type VoiceInfo = Pick<SpeechSynthesisVoice, 'lang' | 'name'>;

export type ISpeechState = SpeechOptions & {
  isPlaying: boolean;
  status: string;
  voiceInfo: VoiceInfo;
};

enum Status {
  init,
  play,
  pause,
  end,
}

const useSpeech = (text: string, options: ISpeechOptions): ISpeechState

Same as we have in react-use

[xobotyi]

@malavshah9 sold!

[malavshah9]

@xobotyi I wanted to work and port below mentioned hooks:

1. useIdle
2. useRaf
3. useGeolocation
4. useStateList

[xobotyi]

@malavshah9 it would be way better if youll help with tests migration so we can switch towards react 18

#1377

I will update that PR so it is containing only tests changes without, and after that youll be able to migrate tests

[malavshah9]

@xobotyi I would love to do that. Should I start migrating that for each hooks and giving you separate PR?