@react-hookz/web

What is @react-hookz/web?

@react-hookz/web is a collection of React hooks designed to simplify common web development tasks. It provides a wide range of hooks for state management, side effects, DOM interactions, and more, making it easier to build complex web applications with React.

What are @react-hookz/web's main functionalities?

State Management

The useToggle hook provides a simple way to manage boolean state. It returns the current state and a function to toggle the state.

import { useToggle } from '@react-hookz/web';

function ToggleComponent() {
  const [value, toggle] = useToggle();

  return (
    <div>
      <p>{value ? 'ON' : 'OFF'}</p>
      <button onClick={toggle}>Toggle</button>
    </div>
  );
}

Side Effects

The useDebounce hook delays the update of a value until after a specified delay. This is useful for scenarios like search input where you want to wait for the user to stop typing before performing an action.

import { useDebounce } from '@react-hookz/web';

function SearchComponent() {
  const [query, setQuery] = useState('');
  const debouncedQuery = useDebounce(query, 500);

  useEffect(() => {
    if (debouncedQuery) {
      // Perform search
    }
  }, [debouncedQuery]);

  return (
    <input
      type="text"
      value={query}
      onChange={(e) => setQuery(e.target.value)}
    />
  );
}

DOM Interactions

The useEventListener hook allows you to easily add and clean up event listeners. In this example, a click event listener is added to the window object.

import { useEventListener } from '@react-hookz/web';

function ClickLogger() {
  useEventListener(window, 'click', () => {
    console.log('Window clicked');
  });

  return <div>Click anywhere to log a message</div>;
}

Other packages similar to @react-hookz/web

react-use

react-use is a collection of essential React hooks. It offers a wide range of hooks for state management, side effects, lifecycle events, and more. Compared to @react-hookz/web, react-use has a larger community and more extensive documentation.

ahooks

ahooks is a React hooks library that provides a set of high-quality and reliable hooks. It focuses on performance and ease of use. ahooks offers similar functionalities to @react-hookz/web but also includes some unique hooks for advanced use cases.

usehooks-ts

usehooks-ts is a collection of React hooks written in TypeScript. It provides type-safe hooks for common tasks in React applications. Compared to @react-hookz/web, usehooks-ts is more focused on TypeScript users and offers type safety out of the box.

README

× DOCS × DISCORD × CHANGELOG ×

---

@react-hookz/web is a library of general-purpose React hooks built with care and SSR compatibility in mind.

Install

This one is pretty simple, everyone knows what to do:

npm i @react-hookz/web
# or
yarn add @react-hookz/web

As hooks was introduced to the world in React 16.8, @react-hookz/web requires - you guessed it - react and react-dom 16.8+. Also, as React does not support IE, @react-hookz/web does not do so either. You'll have to transpile your node-modules in order to run in IE.

Usage

This package provides three levels of compilation:

1. Main, the /cjs folder — CommonJS modules, with ES5 lang level.
2. ESM, the /esm folder — ES modules (browser compatible), with ES5 lang level.
3. ESNext, the /esnext folder — ES modules (browser compatible), with ESNext lang level.

So, if you need the useMountEffect hook, depending on your needs, you can import it in three ways (there are actually more, but these are the three most common):

// in case you need cjs modules
import { useMountEffect } from '@react-hookz/web';
// in case you need esm modules
import { useMountEffect } from '@react-hookz/web/esm';
// in case you want all the recent ES features
import { useMountEffect } from '@react-hookz/web/esnext';

Migrating from react-use

@react-hookz/web was built as a spiritual successor of react-use by one of its former maintainers.

Coming from react-use? Check out our migration guide.

Hooks list

• Callback

  • useDebouncedCallback — Makes passed function debounced, otherwise acts like useCallback.
  • useRafCallback — Makes passed function to be called within next animation frame.
  • useThrottledCallback — Makes passed function throttled, otherwise acts like useCallback.

• Lifecycle

  • useConditionalEffect — Like useEffect but callback invoked only if given conditions match a given predicate.
  • useCustomCompareEffect — Like useEffect but uses a provided comparator function to validate dependency changes.
  • useDebouncedEffect — Like useEffect, but passed function is debounced.
  • useDeepCompareEffect — Like useEffect but uses @react-hookz/deep-equal comparator function to validate deep dependency changes.
  • useFirstMountState — Returns a boolean that is true only on first render.
  • useIntervalEffect — Like setInterval but in the form of a React hook.
  • useIsMounted — Returns a function that yields current mount state.
  • useIsomorphicLayoutEffect — Like useLayoutEffect but falls back to useEffect during SSR.
  • useMountEffect — Run an effect only when a component mounts.
  • useRafEffect — Like useEffect, but the effect is only run within an animation frame.
  • useRerender — Returns a callback that re-renders the component.
  • useThrottledEffect — Like useEffect, but the passed function is throttled.
  • useTimeoutEffect — Like setTimeout, but in the form of a React hook.
  • useUnmountEffect — Run an effect only when a component unmounts.
  • useUpdateEffect — An effect hook that ignores the first render (not invoked on mount).
  • useLifecycleLogger — This hook provides logging when the component mounts, updates and unmounts.

• State

  • useControlledRerenderState — Like useState, but its state setter accepts an extra argument, that allows cancelling renders.
  • useCounter — Tracks a numeric value and offers functions for manipulating it.
  • useDebouncedState — Like useSafeState but its state setter is debounced.
  • useFunctionalState — Like useState but instead of raw state, a state getter function is returned.
  • useList — Tracks a list and offers functions for manipulating it.
  • useMap — Tracks the state of a Map.
  • useMediatedState — Like useState, but every value set is passed through a mediator function.
  • usePrevious — Returns the value passed to the hook on previous render.
  • usePreviousDistinct — Returns the most recent distinct value passed to the hook on previous renders.
  • useRafState — Like React.useState, but state is only updated within animation frame.
  • useRenderCount — Tracks component's render count including first render.
  • useSafeState — Like useState, but its state setter is guarded against setting the state of an unmounted component.
  • useSet — Tracks the state of a Set.
  • useToggle — Like useState, but can only be true or false.
  • useThrottledState — Like useSafeState but its state setter is throttled.
  • useValidator — Performs validation when any of the provided dependencies change.

• Navigator

  • useNetworkState — Tracks the state of the browser's network connection.
  • useVibrate — Provides vibration feedback using the Vibration API.
  • usePermission — Tracks the state of a permission.

• Miscellaneous

  • useSyncedRef — Like useRef, but it returns an immutable ref that contains the actual value.
  • useCustomCompareMemo — Like useMemo but uses provided comparator function to validate dependency changes.
  • useDeepCompareMemo — Like useMemo but uses @react-hookz/deep-equal comparator function to validate deep dependency changes.
  • useHookableRef — Like useRef but it is possible to define handlers for getting and setting the value.

• Side-effect

  • useAsync — Executes provided async function and tracks its results and errors.
  • useAsyncAbortable — Like useAsync, but also provides AbortSignal as first function argument to the async function.
  • useCookieValue — Manages a single cookie.
  • useLocalStorageValue — Manages a single LocalStorage key.
  • useSessionStorageValue — Manages a single SessionStorage key.

• Sensor

  • useIntersectionObserver — Observe changes in the intersection of a target element with an ancestor element or with the viewport.
  • useMeasure — Uses ResizeObserver to track an element's dimensions and to re-render the component when they change.
  • useMediaQuery — Tracks the state of a CSS media query.
  • useResizeObserver — Invokes a callback whenever ResizeObserver detects a change to the target's size.
  • useScreenOrientation — Checks if the screen is in portrait or landscape orientation and automatically re-renders on orientation change.

• Dom

  • useClickOutside — Triggers a callback when user clicks outside the target element.
  • useEventListener — Subscribes an event listener to the target and automatically unsubscribes it on unmount.
  • useKeyboardEvent — Executes a callback whenever a keyboard event occurs on the target.
  • useWindowSize — Tracks the inner dimensions of the window.

Contributors

Anton Zinovyev	Joe Duncko	Arttu Olli	Kyle Holmberg	Andreas Nel	Rey Wang	Axel Bocciarelli	Bart Lens
Birant İyigün	Brian Fletcher	Null	Daniel Friesen	Jake Ketcheson	Joshua Stewart	Konrad Linkowski	Michał Tarasiuk
Fengkx

Changelog

20.0.0 (2022-12-02)

Bug Fixes

• useMediaQuery: add option to martch media query on first render (#1020) (087b2b1), closes #1000

BREAKING CHANGES

• useMediaQuery: useMediaQuery and useScreenOrientation now returns matched media query state on first render by default, SSR users can change that behaviour via hook options.