Categories
React Hooks

Top React Hooks — Placeholder and Titles

Hooks contains our logic code in our React app.

We can create our own hooks and use hooks provided by other people.

In this article, we’ll look at some useful React hooks.

react-optimistic-ui-hook

The react-optimistic-ui-hook library lets us create a UI that doesn’t wait for an operation to finish to update the final state.

They immediately switch to the final state and show fake data while the read ones are loading.

We can install it by running:

npm install react-optimistic-ui-hook

or:

yarn add react-optimistic-ui-hook

Then we can use it by writing:

import React from "react";
import { useOptimisticUI } from "react-optimistic-ui-hook";

const USERNAME = "facebook";
const PREDICTED_AVATAR_URL = "http://placekitten.com/200/200";
const DELAY_IN_MS = 2000;

async function getGithubAvatarURL(username) {
  const response = await fetch(`https://api.github.com/users/${username}`);
  const data = await response.json();

  return new Promise(resolve => {
    setTimeout(() => {
      resolve(data.avatar_url);
    }, DELAY_IN_MS);
  });
}

export default function App() {
  const { status, result, error } = useOptimisticUI(
    () => getGithubAvatarURL(USERNAME),
    PREDICTED_AVATAR_URL
  );

  return (
    <div>
      <img src={result} alt="avatar" />
      <p>Status: {status}</p>
      <p>Error: {JSON.stringify(error)}</p>
    </div>
  );
}

We have the getGithubAvatarURL function that gets the avatar of the Github user asynchronously.

Then we can use that with the useOptimisticUI hook to run the promise.

The first argument has the callback that gets the data.

The 2nd is the URL for the placeholder to show when the real data is being downloaded.

The hook returns the status which is the loading status of the image.

result is the result, which is the resolved value of the promise returned from getGithubAvatarURL .

error has any errors that occurred.

React Page Name

React Page Name is a library that lets us update the page title in our React app.

To install it, we run:

npm install react-page-name

Then we can use it by writing:

import React from "react";
import { usePageName } from "react-page-name";

export default function App() {
  usePageName("hello world");

  return <div>hello world</div>;
}

The usePageName hook takes the string with the page title as an argument.

It also comes with a higher-order component.

For instance, we can write:

import React from "react";
import { withPageName } from "react-page-name";

let Page = () => {
  return <div>hello world</div>;
};

Page = withPageName("hello world")(Page);

export default function App() {
  return (
    <div>
      <Page />
    </div>
  );
}

We created the Page component and used the withPageName higher-order component to set the page title.

The higher-order component will also make the setPageName method available to our component, so we can write:

import React from "react";
import { withPageName } from "react-page-name";

let Page = ({ setPageName }) => {
  setPageName("hello world");

  return <div>hello world</div>;
};

Page = withPageName()(Page);

export default function App() {
  return (
    <div>
      <Page />
    </div>
  );
}

Conclusion

react-optimistic-ui-hook lets us show a placeholder until the real data is loaded.

React Page Name lets us change the page title with a hook or higher-order component.

Categories
React Hooks

Top React Hooks — Outside Clicks and Dimensions

Hooks contains our logic code in our React app.

We can create our own hooks and use hooks provided by other people.

In this article, we’ll look at some useful React hooks.

React Cool Dimensions

React Cool Dimensions lets us watch the dimension of a component.

To use it, we install it by running:

yarn add react-cool-dimensions

or

npm install --save react-cool-dimensions

Then we can use it by writing:

import React from "react";
import useDimensions from "react-cool-dimensions";

export default function App() {
  const { ref, ...dimensions } = useDimensions({
    onResize: ({ width, height, entry, unobserve, observe }) => {
      //...
    }
  });
  return (
    <div className="App">
      <div ref={ref}>{JSON.stringify(dimensions)}</div>
    </div>
  );
}

We use the useDimensions hook which returns the ref that we can assign to the element we want to watch the size for.

Then dimensions has the object with width and height of the element we’re watching.

onResize is a method that runs when we resize the element.

We can also assign breakpoints so the hook can determine the breakpoint when watching the element size.

For instance, we can write:

import React from "react";
import useDimensions from "react-cool-dimensions";

export default function App() {
  const { ref, ...dimensions } = useDimensions({
    breakpoints: { XS: 0, SM: 320, MD: 480, LG: 640 },
    onResize: ({ currentBreakpoint }) => {
      console.log(currentBreakpoint);
    }
  });
  return (
    <div className="App">
      <div ref={ref}>{JSON.stringify(dimensions)}</div>
    </div>
  );
}

We added the breakpoints property to get the breakpoints according to what we assigned.

All the dimensions are in pixels.

We can include the border size with the measurement.

For instance, we can write:

import React from "react";
import useDimensions from "react-cool-dimensions";

export default function App() {
  const { ref, ...dimensions } = useDimensions({
    useBorderBoxSize: true
  });
  return (
    <div className="App">
      <div
        ref={ref}
        style={{
          border: "5px solid grey"
        }}
      >
        {JSON.stringify(dimensions)}
      </div>
    </div>
  );
}

Then the border is included with the measurements.

To throttle the watching, we can throttle the onResize callback calls with the Lodash throttle method.

We can also create our own ref and pass it into the useDimensions hook’s object argument’s ref property.

React Cool Onclickoutside

React Cool Onclickoutside lets us detect clicks outside an element.

To install it, we run:

yarn add react-cool-onclickoutside

or:

npm install --save react-cool-onclickoutside

Then we can use it by writing:

import React from "react";
import useOnclickOutside from "react-cool-onclickoutside";

export default function App() {
  const [openMenu, setOpenMenu] = React.useState(false);
  const ref = useOnclickOutside(() => {
    setOpenMenu(false);
  });

  const handleClickBtn = () => {
    setOpenMenu(!openMenu);
  };

  return (
    <div>
      <button onClick={handleClickBtn}>Button</button>
      {openMenu && <div ref={ref}>Menu</div>}
    </div>
  );
}

useOnclickOutside is the hook that comes with the package to detect clicks outside an element.

It returns a ref which we can pass into the ref prop of the element we want to watch the clicks outside for.

Now when we click outside the menu div, the menu will disappear.

Conclusion

React Cool Dimensions lets us watch the dimensions of our elements.

React Cool Onclickoutside lets us detect clicks that are outside an element.

Categories
React Hooks

Top React Hooks — Online Status, Timers, and Previous State

Hooks contains our logic code in our React app.

We can create our own hooks and use hooks provided by other people.

In this article, we’ll look at some useful React hooks.

React hookedUp

React hookedUp is a library with many hooks to make our lives easier.

To install it, we run:

npm install react-hookedup --save

or:

yarn add react-hookedup

The useMergeState lets us set the state as we did with setState in React class components.

For instance, we can use it by writing:

import React from "react";
import { useMergeState } from "react-hookedup";

export default function App() {
  const { state, setState } = useMergeState({ loading: false });

  return (
    <div>
      <button onClick={() => setState({ loading: !state.loading })}>
        toggle
      </button>
      <p>{state.loading.toString()}</p>
    </div>
  );
}

We have the useMergeState to let us manage object states easily.

It returns an object with the state and setState properties.

state has the current state value.

setState is the function to set the state.

We use it by passing in an object with the property and value.

The usePrevious hook lets us get the previous value from the useState hook.

For instance, we can write:

import React from "react";
import { usePrevious } from "react-hookedup";

export default function App() {
  const [count, setCount] = React.useState(0);
  const prevCount = usePrevious(count);
  return (
    <>
      <button onClick={() => setCount(count => count + 1)}>increment</button>
      <p>
        Now: {count}, before: {prevCount}
      </p>
    </>
  );
}

We use the usePrevious hook by passing in the state value into it.

Then we can get the previous value with the value returned by the hook.

The useInterval hook lets us run setInterval the React way.

For instance, we can write:

import React from "react";
import { useInterval } from "react-hookedup";

export default function App() {
  const [count, setCount] = React.useState(0);
  useInterval(() => setCount(count => count + 1), 1000);

  return <h1>{count}</h1>;
}

We used the useInterval hook with a callback that’s called every second as we specified in the 2nd argument.

The number is in milliseconds.

Then count is updated every second.

The useTimeout hook lets us run setTimeout with a convenient hook.

For example, we can write:

import React from "react";
import { useTimeout } from "react-hookedup";

export default function App() {
  useTimeout(() => alert("hello world"), 1500);

  return (
    <>
      <p>hello</p>
    </>
  );
}

The useTimeout hook takes a callback which runs after the time given in the 2nd argument.

The number is in milliseconds.

The useOnlineStatus hook lets us get the current online status.

For instance, we can use it by writing:

import React from "react";
import { useOnlineStatus } from "react-hookedup";

export default function App() {
  const { online } = useOnlineStatus();

  return <h1>{online ? "online" : "offline"}</h1>;
}

We just call the hook and that returns an object with the online property.

It indicates whether our app is online or not.

Conclusion

React hookedUp has many useful hooks.

We can set the previous state, use timers, and get online status with the provided hooks.

Categories
React Hooks

Top React Hooks — Mouse, Keyboard, and States

Hooks contains our logic code in our React app.

We can create our own hooks and use hooks provided by other people.

In this article, we’ll look at some useful React hooks.

react-hanger

The react-hanger library comes with various hooks we can use to do various things.

To install it, we run:

yarn add react-hanger

The usePrevious hook lets us get the previous value from the useState hook.

For instance, we can write:

import React from "react";
import { usePrevious } from "react-hanger";

export default function App() {
  const [count, setCount] = React.useState(0);
  const prevCount = usePrevious(count);
  return (
    <>
      <button onClick={() => setCount(count => count + 1)}>increment</button>
      <p>
        Now: {count}, before: {prevCount}
      </p>
    </>
  );
}

Then we have the count state with the setCount function returned from useState .

Then we pass the count state into the usePrevious hook to get the previous value of the count state returned.

React Mighty Mouse

React Mighty Mouse is a library with a hook that lets us track the mouse position.

To install it, we can run:

npm install react-hook-mighty-mouse

Then we can use it by writing:

import React from "react";
import useMightyMouse from "react-hook-mighty-mouse";

export default function App() {
  const { position } = useMightyMouse();
  return (
    <div>
      x:{position.client.x} y:{position.client.y}
    </div>
  );
}

We use the useMightyMouse hook to get an object with the position property.

Then we can get the mouse position as we move it with the client.x and client.y properties to get the x and y coordinates respectively.

react-hook-mousetrap

The react-hook-mousetrap library lets us watch for presses of a keyboard key combination.

We install it by running:

npm i react-hook-mousetrap

Then we can use it by writing:

import React from "react";
import useMousetrap from "react-hook-mousetrap";

export default function App() {
  useMousetrap(
    "ctrl+enter", () => {
      console.log("ctrl+enter pressed");
    }
  );

  return <div />;
}

We use the useMousetrap hook with the first argument being the key combination we want to track.

And the 2nd argument is the callback to run when the key combination is pressed.

React hookedUp

React hookedUp is a library with many hooks to make our lives easier.

To install it, we run:

npm install react-hookedup --save

or:

yarn add react-hookedup

Then we can start using various hooks that it comes with.

It comes with the useArray hook to let us manipulate arrays easily.

For instance, we can write:

import React from "react";
import { useArray } from "react-hookedup";

export default function App() {
  const { add, clear, removeIndex, value: currentArray } = useArray([
    "cat",
    "dog",
    "bird"
  ]);

  return (
    <>
      <button onClick={() => add("moose")}>add</button>
      <button onClick={() => clear()}>clear</button>
      <button onClick={() => removeIndex(currentArray.length - 1)}>
        remove index
      </button>
      <p>{currentArray.join(", ")}</p>.
    </>
  );
}

We have the useArray hook with the initial array as the value.

Then it returns the add , clear , and removeIndex methods to let us manipulate the array.

value has the current value.

add lets us append an entry.

clear clears the array.

removeIndex removes an item by its index.

Conclusion

The react-hanger and React hookedUp libraries comes with many hooks to help us manage states.

React Mighty Mouse and react-hook-mousetrap lets us watch for mouse position changes and key combo presses respectively.

Categories
React Hooks

Top React Hooks — Modals and Visibility

Hooks contains our logic code in our React app.

We can create our own hooks and use hooks provided by other people.

In this article, we’ll look at some useful React hooks.

react-hooks-use-modal

The react-hooks-use-modal library lets us create a modal with ease.

To install it, we run:

npm i react-hooks-use-modal

Then we can use it by writing:

import React from "react";
import useModal from "react-hooks-use-modal";

export default function App() {
  const [Modal, open, close, isOpen] = useModal("root", {
    preventScroll: true
  });
  return (
    <div>
      <p>{isOpen ? "Yes" : "No"}</p>
      <button onClick={open}>OPEN</button>
      <Modal>
        <div>
          <h1>Title</h1>
          <p>hello world.</p>
          <button onClick={close}>CLOSE</button>
        </div>
      </Modal>
    </div>
  );
}

We use the useModal hook with some arguments.

The first argument is the ID of the element the modal attaches to.

The 2nd argument has some options.

preventScroll prevents the body from being scrolled when it’s set to true .

Then we can use the array of things it returns.

Modal has the modal component.

open is the function to open the modal.

close is the function to close the modal.

isOpen has the state to indicate whether the modal is open or not.

react-hooks-visible

The react-hooks-visible library provides us with a hook to detect the visibility of an element.

It uses the Observer API to detect the visibility of the element.

The install it, we run:

yarn add react-hooks-visible

Then we can use it by writing:

import React from "react";
import { useVisible } from "react-hooks-visible";

export default function App() {
  const [targetRef, visible] = useVisible();
  return (
    <div ref={targetRef}>
      <p style={{ position: "fixed" }}>{visible * 100} % visible</p>
      {Array(1000)
        .fill()
        .map((_, i) => (
          <p>{i}</p>
        ))}
    </div>
  );
}

We use the useVisible hook to return the targetRef , which we pass into the ref prop of the element we want to watch.

visible returns the percent of the element that’s visible.

It’s updated as the visibility percentage changes.

We can also pass an argument into the hook to format the number.

For instance, we can write:

import React from "react";
import { useVisible } from "react-hooks-visible";

export default function App() {
  const [targetRef, visible] = useVisible(vi => (vi * 100).toFixed(2));
  return (
    <div ref={targetRef}>
      <p style={{ position: "fixed" }}>{visible} % visible</p>
      {Array(1000)
        .fill()
        .map((_, i) => (
          <p>{i}</p>
        ))}
    </div>
  );
}

to round the visible number to 2 decimal places.

We can also return something other than a number.

For example, we can write:

import React from "react";
import { useVisible } from "react-hooks-visible";

export default function App() {
  const [targetRef, isVisible] = useVisible(vi => vi > 0.5);
  return (
    <div ref={targetRef}>
      <p style={{ position: "fixed" }}>{isVisible.toString()} </p>
      {Array(10)
        .fill()
        .map((_, i) => (
          <p>{i}</p>
        ))}
    </div>
  );
}

We have a callback that returns a boolean expression which compares the visibility decimal to 0.5.

isVisible would be a boolean to indicate whether the element is more than half visible.

Conclusion

The react-hooks-use-modal library lets us create a modal easily.

The react-hooks-visible lets us watch for the visibility of an element.