[Solved]-How to listen for click events that are outside of a component-Reactjs

use the excellent react-onclickoutside mixin:

npm install --save react-onclickoutside

and then

var component = react.createclass({
  mixins: [
    require('react-onclickoutside')
  ],
  handleclickoutside: function(evt) {
    // ...handling code goes here... 
  }
});

i found a simpler way about this.

you just need to add onhide(this.closefunction) on the modal

<modal onhide={this.closefunction}>
...
</modal>

assuming you have a function to close the modal.

super late to the party, but i've had success with setting a blur event on the parent element of the dropdown with the associated code to close the dropdown, and also attaching a mousedown listener to the parent element that checks if the dropdown is open or not, and will stop the event propagation if it is open so that the blur event won't be triggered.

since the mousedown event bubbles up this will prevent any mousedown on children from causing a blur on the parent.

/* some react component */
...

showfoo = () => this.setstate({ showfoo: true });

hidefoo = () => this.setstate({ showfoo: false });

clicked = e => {
    if (!this.state.showfoo) {
        this.showfoo();
        return;
    }
    e.preventdefault()
    e.stoppropagation()
}

render() {
    return (
        <div 
            onfocus={this.showfoo}
            onblur={this.hidefoo}
            onmousedown={this.clicked}
        >
            {this.state.showfoo ? <foocomponent /> : null}
        </div>
    )
}

...

e.preventdefault() shouldn't have to be called as far as i can reason but firefox doesn't play nice without it for whatever reason. works on chrome, firefox, and safari.

you could use refs to achieve this, something like the following should work.

add the ref to your element:

<div ref={(element) => { this.myelement = element; }}></div>

you can then add a function for handling the click outside of the element like so:

handleclickoutside(e) {
  if (!this.myelement.contains(e)) {
    this.setstate({ myelementvisibility: false });
  }
}

then finally, add and remove the event listeners on will mount and will unmount.

componentwillmount() {
  document.addeventlistener('click', this.handleclickoutside, false);  // assuming that you already did .bind(this) in constructor
}

componentwillunmount() {
  document.removeeventlistener('click', this.handleclickoutside, false);  // assuming that you already did .bind(this) in constructor
}

1. create a fixed layer that spans the whole screen (.backdrop).
2. have the target element (.target) outside the .backdrop element and with a greater stacking index (z-index).

then any click on the .backdrop element will be considered "outside of the .target element".

.click-overlay {
    position: fixed;
    left: 0;
    right: 0;
    top: 0;
    bottom: 0;
    z-index: 1;
}

.target {
    position: relative;
    z-index: 2;
}

• here is an example: http://jsfiddle.net/lhmwd/
• more on the discussion: https://github.com/facebook/react/issues/579

i voted up one of the answers even though it didn't work for me. it ended up leading me to this solution. i changed the order of operations slightly. i listen for mousedown on the target and mouseup on the target. if either of those return true, we don't close the modal. as soon as a click is registered, anywhere, those two booleans { mousedownonmodal, mouseuponmodal } are set back to false.

componentdidmount() {
    document.addeventlistener('click', this._handlepageclick);
},

componentwillunmount() {
    document.removeeventlistener('click', this._handlepageclick);
},

_handlepageclick(e) {
    var wasdown = this.mousedownonmodal;
    var wasup = this.mouseuponmodal;
    this.mousedownonmodal = false;
    this.mouseuponmodal = false;
    if (!wasdown && !wasup)
        this.close();
},

_handlemousedown() {
    this.mousedownonmodal = true;
},

_handlemouseup() {
    this.mouseuponmodal = true;
},

render() {
    return (
        <modal onmousedown={this._handlemousedown} >
               onmouseup={this._handlemouseup}
            {/* other_content_here */}
        </modal>
    );
}

this has the advantage that all the code rests with the child component, and not the parent. it means that there's no boilerplate code to copy when reusing this component.

i have written a generic event handler for events that originate outside of the component, react-outside-event.

the implementation itself is simple:

• when component is mounted, an event handler is attached to the window object.
• when an event occurs, the component checks whether the event originates from within the component. if it does not, then it triggers onoutsideevent on the target component.
• when component is unmounted, the event handler is detacthed.

import react from 'react';
import reactdom from 'react-dom';

/**
 * @param {reactclass} target the component that defines `onoutsideevent` handler.
 * @param {string[]} supportedevents a list of valid dom event names. default: ['mousedown'].
 * @return {reactclass}
 */
export default (target, supportedevents = ['mousedown']) => {
    return class reactoutsideevent extends react.component {
        componentdidmount = () => {
            if (!this.refs.target.onoutsideevent) {
                throw new error('component does not defined "onoutsideevent" method.');
            }

            supportedevents.foreach((eventname) => {
                window.addeventlistener(eventname, this.handleevent, false);
            });
        };

        componentwillunmount = () => {
            supportedevents.foreach((eventname) => {
                window.removeeventlistener(eventname, this.handleevent, false);
            });
        };

        handleevent = (event) => {
            let target,
                targetelement,
                isinside,
                isoutside;

            target = this.refs.target;
            targetelement = reactdom.finddomnode(target);
            isinside = targetelement.contains(event.target) || targetelement === event.target;
            isoutside = !isinside;



            if (isoutside) {
                target.onoutsideevent(event);
            }
        };

        render() {
            return <target ref='target' {... this.props} />;
        }
    }
};

to use the component, you need wrap the target component class declaration using the higher order component and define the events that you want to handle:

import react from 'react';
import reactdom from 'react-dom';
import reactoutsideevent from 'react-outside-event';

class player extends react.component {
    onoutsideevent = (event) => {
        if (event.type === 'mousedown') {

        } else if (event.type === 'mouseup') {

        }
    }

    render () {
        return <div>hello, world!</div>;
    }
}

export default reactoutsideevent(player, ['mousedown', 'mouseup']);

for your specific use case, the currently accepted answer is a tad over-engineered. if you want to listen for when a user clicks out of a dropdown list, simply use a <select> component as the parent element and attach an onblur handler to it.

the only drawbacks to this approach is that it assumes the user has already maintained focus on the element, and it relies on a form control (which may or may not be what you want if you take into account that the tab key also focuses and blurs elements) - but these drawbacks are only really a limit for more complicated use cases, in which case a more complicated solution might be necessary.

 var dropdown = react.createclass({

   handleblur: function(e) {
     // do something when user clicks outside of this element
   },

   render: function() {
     return (
       <select onblur={this.handleblur}>
         ...
       </select>
     );
   }
 });

look at the target of the event, if the event was directly on the component, or children of that component, then the click was inside. otherwise it was outside.

react.createclass({
    clickdocument: function(e) {
        var component = react.finddomnode(this.refs.component);
        if (e.target == component || $(component).has(e.target).length) {
            // inside of the component.
        } else {
            // outside of the component.
        }

    },
    componentdidmount: function() {
        $(document).bind('click', this.clickdocument);
    },
    componentwillunmount: function() {
        $(document).unbind('click', this.clickdocument);
    },
    render: function() {
        return (
            <div ref='component'>
                ...
            </div> 
        )
    }
});

if this is to be used in many components, it is nicer with a mixin:

var clickmixin = {
    _clickdocument: function (e) {
        var component = react.finddomnode(this.refs.component);
        if (e.target == component || $(component).has(e.target).length) {
            this.clickinside(e);
        } else {
            this.clickoutside(e);
        }
    },
    componentdidmount: function () {
        $(document).bind('click', this._clickdocument);
    },
    componentwillunmount: function () {
        $(document).unbind('click', this._clickdocument);
    },
}

see example here: https://jsfiddle.net/0lshs7mg/1/

using the life-cycle methods add and remove event listeners to the document.

react.createclass({
    handleclick: function (e) {
        if (this.getdomnode().contains(e.target)) {
            return;
        }
    },

    componentwillmount: function () {
        document.addeventlistener('click', this.handleclick, false);
    },

    componentwillunmount: function () {
        document.removeeventlistener('click', this.handleclick, false);
    }
});

check out lines 48-54 of this component: https://github.com/i-like-robots/react-tube-tracker/blob/91dc0129a1f6077bef57ea4ad9a860be0c600e9d/app/component/tube-tracker.jsx#l48-54