Wednesday March 3, 2021 By David Quintanilla
Creating An Outside Focus And Click Handler React Component — Smashing Magazine

About The Writer

Arihant Verma is a Software program Engineer based mostly in India. He likes to learn open supply code and assist others perceive it. He’s a wealthy textual content editors fanatic. His …
More about

On this article, we’ll have a look at the best way to create an outdoor focus and click on handler with React. You’ll learn to recreate an open-source React element (react-foco) from scratch in doing so. To get probably the most out of this text, you’ll want a primary understanding of JavaScript courses, DOM occasion delegation and React. By the top of the article, you’ll understand how you should use JavaScript class occasion properties and occasion delegation to create a React element that helps you detect a click on or focus exterior of any React element.

Oftentimes we have to detect when a click on has occurred exterior of a component or when the main focus has shifted exterior of it. A number of the evident examples for this use case are fly-out menus, dropdowns, tooltips and popovers. Let’s begin the method of creating this detection performance.

The DOM Method To Detect Outdoors Click on

When you had been requested to put in writing code to detect if a click on occurred inside a DOM node or exterior of it, what would you do? Chances are high you’d use the Node.contains DOM API. Right here’s how MDN explains it:

The Node.incorporates() methodology returns a Boolean worth indicating whether or not a node is a descendant of a given node, i.e. the node itself, certainly one of its direct kids (childNodes), one of many kids’s direct kids, and so forth.

Let’s shortly check it out. Let’s make a component we wish to detect exterior click on for. I’ve conveniently given it a click-text class.

  <div class="click-text">
    click on inside and out of doors me
const concernedElement = doc.querySelector(".click-text");

doc.addEventListener("mousedown", (occasion) => {
  if (concernedElement.incorporates(occasion.goal)) {
    console.log("Clicked Inside");
  } else {
    console.log("Clicked Outdoors / Elsewhere");

We did the next issues:

  1. Chosen the HTML aspect with the category click-text.
  2. Put a mouse down occasion listener on doc and set an occasion handler callback perform.
  3. Within the callback perform, we’re checking if our involved aspect — for which now we have to detect exterior click on — incorporates the aspect (together with itself) which triggered the mousedown occasion (occasion.goal).

If the aspect which triggered the mouse down occasion is both our involved aspect or any aspect which is contained in the involved aspect, it means now we have clicked inside our involved aspect.

Let’s click on inside and out of doors of the aspect within the Codesandbox under, and examine the console.

Wrapping DOM Hierarchy Primarily based Detection Logic In A React Part

Nice! Thus far we noticed the best way to use DOM’s Node.incorporates API to detect click on exterior of a component. We are able to wrap that logic in a React element. We might identify our new React element OutsideClickHandler. Our OutsideClickHandler element will work like this:

  onOutsideClick={() => {
    console.log("I'm referred to as each time click on occurs exterior of 'AnyOtherReactComponent' element")
  <AnyOtherReactComponent />

OutsideClickHandler takes in two props:

  1. kids
    It may very well be any legitimate React kids. Within the instance above we’re passing AnyOtherReactComponent element as OutsideClickHandler’s youngster.

  2. onOutsideClick
    This perform shall be referred to as if a click on occurs anyplace exterior of AnyOtherReactComponent element.

Sounds good thus far? Let’s truly begin constructing our OutsideClickHandler element.

import React from 'react';

class OutsideClickHandler extends React.Part {
  render() {
    return this.props.kids;

Only a primary React element. Thus far, we aren’t doing a lot with it. We’re simply returning the youngsters as they’re handed to our OutsideClickHandler element. Let’s wrap the kids with a div aspect and fix a React ref to it.

import React, { createRef } from 'react';

class OutsideClickHandler extends React.Part {
  wrapperRef = createRef();

  render() {    
    return (
      <div ref={this.wrapperRef}>

We’ll use this ref to get entry to the DOM node object related to the div aspect. Utilizing that, we’ll recreate the surface detection logic we made above.

Let’s connect mousedown occasion on doc inside componentDidMount React life cycle methodology, and clear up that occasion inside componentWillUnmount React lifecycle methodology.

class OutsideClickHandler extends React.Part {
  componentDidMount() {
      .addEventListener('mousedown', this.handleClickOutside);

      .removeEventListener('mousedown', this.handleClickOutside);

  handleClickOutside = (occasion) => {
    // Right here, we'll write the identical exterior click on
    // detection logic as we used earlier than.

Now, let’s write the detection code inside handleClickOutside handler perform.

class OutsideClickHandler extends React.Part {
  componentDidMount() {
      .addEventListener('mousedown', this.handleClickOutside);

      .removeEventListener('mousedown', this.handleClickOutside);

  handleClickOutside = (occasion) => {
    if (
      this.wrapperRef.present &&
    ) {

The logic inside handleClickOutside methodology says the next:

If the DOM node that was clicked (occasion.goal) was neither our container div (this.wrapperRef.present) nor was it any node inside it (!this.wrapperRef.present.incorporates(occasion.goal)), we name the onOutsideClick prop.

This could work in the identical means as the surface click on detection had labored earlier than. Let’s attempt clicking exterior of the gray textual content aspect within the codesandbox under, and observe the console:

The Drawback With DOM Hierarchy Primarily based Outdoors Click on Detection Logic

However there’s one drawback. Our React element doesn’t work if any of its kids are rendered in a React portal.

However what are React portals?

“Portals present a first-class method to render kids right into a DOM node that exists exterior the DOM hierarchy of the father or mother element.”

React docs for portals

Image showing that React children rendered in React portal do not follow top down DOM hierarchy.
React kids rendered in React portal don’t comply with prime down DOM hierarchy. (Large preview)

Within the picture above, you may see that although Tooltip React element is a toddler of Container React element, if we examine the DOM we discover that Tooltip DOM node truly resides in a totally separate DOM construction i.e. it’s not contained in the Container DOM node.

The issue is that in our exterior detection logic thus far, we’re assuming that the youngsters of OutsideClickHandler shall be its direct descendants within the DOM tree. Which isn’t the case for React portals. If kids of our element render in a React portal — which is to say they render in a separate DOM node which is exterior the hierarchy of our container div through which our OutsideClickHandler element renders its kids — then the Node.incorporates logic fails.

How would it not fail although? When you’d attempt to click on on the youngsters of our OutsideClickHandler element — which renders in a separate DOM node utilizing React portals — our element will register an outdoor click on, which it shouldn’t. See for your self:

GIF Image showing that if a React child rendered in React portal is clicked, OutsideClickHandler, which uses <code>Node.contains</code>, wrongly registers it as outside click.
Utilizing Node.incorporates to detect exterior click on of React element offers unsuitable end result for kids rendered in a React portal. (Large preview)

Strive it out:

Despite the fact that the popover that opens on clicking the button, is a toddler of OutsideClickHandler element, it fails to detect that it isn’t exterior of it, and closes it down when it’s clicked.

Utilizing Class Occasion Property And Occasion Delegation To Detect Outdoors Click on

So what may very well be the answer? We absolutely can’t depend on DOM to inform us if the press is going on exterior anyplace. We’ll should do one thing with JavaScript by rewriting out OutsideClickHandler implementation.

Let’s begin with a clean slate. So at this second OutsideClickHandler is an empty React class.

The crux of accurately detecting exterior click on is:

  1. To not depend on DOM construction.
  2. To retailer the ‘clicked’ state someplace within the JavaScript code.

For this occasion delegation will come to our assist. Let’s take an instance of the identical button and popover instance we noticed above within the GIF above.

We have now two kids of our OutsideClickHandler perform. A button and a popover — which will get rendered in a portal exterior of the DOM hierarchy of OutsideClickHandler, on button click on, like so:

Diagram showing hierarchy of <code>document</code>, OutsideClickHandler React Component and its children rendered in React portal.
DOM Hierarchy of doc, OutsideClickHandler React Part and its kids rendered in React portal. (Large preview)

When both of our kids are clicked we set a variable clickCaptured to true. If something exterior of them is clicked, the worth of clickCaptured will stay false.

We’ll retailer clickCaptured’s worth in:

  1. A category occasion property, in case you are utilizing a category react element.
  2. A ref, in case you are utilizing a practical React element.

We aren’t utilizing React state to retailer clickCaptured’s worth as a result of we aren’t rendering something based mostly off of this clickCaptured information. The aim of clickCaptured is ephemeral and ends as quickly as we’ve detected if the press has occurred inside or exterior.

Let’s seee within the picture under the logic for setting clickCaptured:

Diagram showing setting of clickCaptured to true variable when children of OutsideClickHandler component are clicked.
When any of the youngsters of OutsideClickHandler element are clicked we set clickCaptured to true. (Large preview)

At any time when a click on occurs anyplace, it bubbles up in React by default. It’ll attain to the doc ultimately.

Diagram showing the value of <strong>clickCaptured</strong> variable when mousedown event bubbles upto document, for both inside and outside click cases.
Worth of clickCaptured variable when mousedown occasion bubbles upto doc, for each inside and out of doors click on instances. (Large preview)

When the press reaches doc, there are two issues which may have occurred:

  1. clickCaptured shall be true, if kids the place clicked.
  2. clickCaptured shall be false, if anyplace exterior of them was clicked.

Within the doc’s occasion listener we are going to do two issues now:

  1. If clickCaptured is true, we hearth an outdoor click on handler that the person of OutsideClickHandler might need given us by way of a prop.
  2. We reset clickCaptured to false, in order that we’re prepared for one more click on detection.
Diagram showing the detection of if click happened inside or outside of React component by checking <strong>clickCapture</strong>’s value when mousedown event reaches document.
Detecting if click on occurred inside or exterior of React element by checking clickCapture’s worth when mousedown occasion reaches doc. (Large preview)

Let’s translate this into code.

import React from 'react'

class OutsideClickHandler extends React.Part {
  clickCaptured = false;
  render() {
    if ( typeof this.props.kids === 'perform' ) {
      return this.props.kids(this.getProps())

    return this.renderComponent()

We have now the next issues:

  1. set preliminary worth of clickCaptured occasion property to false.
  2. Within the render methodology, we examine if kids prop is a perform. Whether it is, we name it and move it all of the props we wish to give it by calling getProps class methodology. We haven’t applied getProps simply but.
  3. If the kids prop isn’t a perform, we name renderComponent methodology. Let’s implement this methodology now.
class OutsideClickHandler extends React.Part {

Since we aren’t utilizing JSX, we’re instantly utilizing React’s createElement API to wrap our kids in both this.props.element or a span. this.props.element generally is a React element or any of the HTML aspect’s tag identify like ‘div’, ‘part’, and so on. We move all of the props that we wish to move to our newly created aspect by calling getProps class methodology because the second argument.

Let’s write the getProps methodology now:

class OutsideClickHandler extends React.Part {
  getProps() {
    return {
      onMouseDown: this.innerClick,
      onTouchStart: this.innerClick

Our newly created React aspect, could have the next props handed right down to it: onMouseDown and onTouchStart for contact gadgets. Each of their values is the innerClick class methodology.

class OutsideClickHandler extends React.Part {
  innerClick = () => {
    this.clickCaptured = true;

If our new React element or something inside it — which may very well be a React portal — is clicked, we set the clickCaptured class occasion property to true. Now, let’s add the mousedown and touchstart occasions to the doc, in order that we are able to seize the occasion that’s effervescent up from under.

class OutsideClickHandler extends React.Part {
    doc.addEventListener('mousedown', this.documentClick);
    doc.addEventListener('touchstart', this.documentClick);

    doc.removeEventListener('mousedown', this.documentClick);
    doc.removeEventListener('touchstart', this.documentClick);

  documentClick = (occasion) => {
    if (!this.clickCaptured && this.props.onClickOutside) {
    this.clickCaptured = false;

Within the doc mousedown and touchstart occasion handlers, we’re checking if clickCaptured is falsy.

  1. clickCaptured would solely be true if kids of our React element would have been clicked.
  2. If anything would have been clicked clickCaptured can be false, and we’d know that exterior click on has occurred.

If clickCaptured is falsy, we’ll name the onClickOutside methodology handed down in a prop to our OutsideClickHandler element.

That’s it! Let’s verify that if we click on contained in the popover it doesn’t get closed now, because it was earlier than:

GIF Image showing that if a React child rendered in React portal is clicked, OutsideClickHandler component, which uses event delegation, correctly registers it as inside click, and not outside click.
Utilizing occasion delegation logic accurately detects exterior click on, even when kids are rendered in a React portal. (Large preview)

Let’s attempt it out:


Outdoors Focus Detection

Now let’s take a step additional. Let’s additionally add performance to detect when focus has shifted exterior of a React element. It’s going to be very related implementation as we’ve accomplished with click on detection. Let’s write the code.

class OutsideClickHandler extends React.Part {
  focusCaptured = false // 1. so as to add this

  innerFocus = () => {
    this.focusCaptured = true;

    doc.addEventListener('mousedown', this.documentClick);
    doc.addEventListener('touchstart', this.documentClick);
    doc.addEventListener('focusin', this.documentFocus);

    doc.removeEventListener('mousedown', this.documentClick);
    doc.removeEventListener('touchstart', this.documentClick);
    doc.removeEventListener('focusin', this.documentFocus);

documentFocus = (occasion) => {
    if (!this.focusCaptured && this.props.onFocusOutside) {
    this.focusCaptured = false;

// 2.  to indent the next piece of code
// 3. This piece of code doesn’t get copied on clipboard on clicking the ‘copy’ button

getProps() { return { onMouseDown: this.innerClick, onTouchStart: this.innerClick, onFocus: this.innerFocus }; }

All the pieces’s added principally in the identical vogue, apart from one factor. You might need observed that although we’re including an onFocus react occasion handler on our kids, we’re setting a focusin occasion listener to our doc. Why not a focus occasion you say? As a result of, 🥁🥁🥁, Starting from v17, React now maps onFocus React event to focusin native event internally.

In case you’re utilizing v16 or earlier than, as an alternative of including a focusin occasion handler to the doc, you’ll have so as to add a focus occasion in seize part as an alternative. In order that’ll be:

doc.addEventListener('focus', this.documentFocus, true);

Why in seize part you may ask? As a result of as bizarre as it’s, focus event doesn’t bubble up.

Since I’m utilizing v17 in all my examples, I’m going to go forward use the previous. Let’s see what now we have right here:

GIF Image showing correction detection of outside click and focus by React Foco component, which uses event delegation detection logic.
React Foco element accurately detecting exterior click on and focus through the use of occasion delegation detection logic. (Large preview)

Let’s attempt it out ourselves, attempt clicking inside and out of doors of the pink background. Additionally use tab and shift + tab keys ( in chrome, firefox, edge ) or Decide/Alt + Tab and Decide/Alt + Shift + Tab ( in Safari ) to toggle focussing between interior and outer button and see how focus standing modifications.


On this article, we realized that probably the most simple method to detect a click on exterior of a DOM node in JavaScript is through the use of Node.incorporates DOM API. I defined the significance of realizing why utilizing the identical methodology to detect clicks exterior of a React element doesn’t work when the React element has kids which render in a React portal. Additionally, now you know the way to make use of a category occasion property alongside an occasion delegation to accurately detect whether or not a click on occurred exterior of a React element, in addition to the best way to lengthen the identical detection approach to exterior focus detection of a React element with the focusin occasion caveat.

  1. React Foco Github Repository
  2. mdn documentation for Node.contains DOM api
  3. React docs for portals
  4. React createElement API
  5. React Github codebase Pull Request for mapping onFocus and onBlur methods to internally use focusin and focusout native events.
  6. Delegating Focus and Blur events
Smashing Editorial
(ks, vf, yk, il)

Source link