event-abstract-class/dist/event-abstract-class.js

ES6 abstract class to extend and allow classes to support native object event binding/triggering.

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Event abstract class
 *
 * Extend to allow classes to support native object event triggering/binding
 */

var EventAbstractClass = function () {
    // region Constructor

    /**
     * Constructor
     */

    function EventAbstractClass() {
        _classCallCheck(this, EventAbstractClass);

        this.events = {};
    }

    // endregion Constructor

    // region Helpers

    /**
     * Split events list string into array
     *
     * @param {String} events String of events to split
     * @returns {Array}
     */


    _createClass(EventAbstractClass, [{
        key: 'getEventList',
        value: function getEventList(events) {
            return events.trim().split(/(?:,|\s)+/g);
        }

        /**
         * Get namespaces from event name string
         *
         * @param {String} event Event name string
         * @returns {Array}
         */

    }, {
        key: 'getNamespaces',
        value: function getNamespaces(event) {
            var namespaces = [],
                splitEvent = event.trim().split(/:+/g);

            for (var i = splitEvent.length; i >= 1; i -= 1) {
                namespaces.push(splitEvent.slice(0, i).join(':'));
            }

            return namespaces;
        }

        // endregion Helpers

        // region Controls

        /**
         * Trigger event
         *
         * @param {String} eventName Name of event to trigger
         * @param {*}      data      Data to pass to event handler
         */

    }, {
        key: 'trigger',
        value: function trigger(eventName) {
            var data = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];

            var events = this.getEventList(eventName);

            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = events[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    var event = _step.value;

                    var namespaces = this.getNamespaces(event);

                    var _iteratorNormalCompletion2 = true;
                    var _didIteratorError2 = false;
                    var _iteratorError2 = undefined;

                    try {
                        for (var _iterator2 = namespaces[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                            var namespace = _step2.value;

                            if (!this.events[namespace]) {
                                continue;
                            }

                            var _iteratorNormalCompletion3 = true;
                            var _didIteratorError3 = false;
                            var _iteratorError3 = undefined;

                            try {
                                for (var _iterator3 = this.events[namespace][Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                                    var handler = _step3.value;

                                    handler.call(this, data);
                                }
                            } catch (err) {
                                _didIteratorError3 = true;
                                _iteratorError3 = err;
                            } finally {
                                try {
                                    if (!_iteratorNormalCompletion3 && _iterator3.return) {
                                        _iterator3.return();
                                    }
                                } finally {
                                    if (_didIteratorError3) {
                                        throw _iteratorError3;
                                    }
                                }
                            }
                        }
                    } catch (err) {
                        _didIteratorError2 = true;
                        _iteratorError2 = err;
                    } finally {
                        try {
                            if (!_iteratorNormalCompletion2 && _iterator2.return) {
                                _iterator2.return();
                            }
                        } finally {
                            if (_didIteratorError2) {
                                throw _iteratorError2;
                            }
                        }
                    }
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }
        }

        /**
         * Bind handler to event
         *
         * @param {String}   eventName Name of event to bind to
         * @param {Function} handler   Event handler function to bind
         */

    }, {
        key: 'on',
        value: function on(eventName, handler) {
            var events = this.getEventList(eventName);

            var _iteratorNormalCompletion4 = true;
            var _didIteratorError4 = false;
            var _iteratorError4 = undefined;

            try {
                for (var _iterator4 = events[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
                    var event = _step4.value;

                    if (!this.events[event]) {
                        this.events[event] = [];
                    }

                    this.events[event].push(handler);
                }
            } catch (err) {
                _didIteratorError4 = true;
                _iteratorError4 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion4 && _iterator4.return) {
                        _iterator4.return();
                    }
                } finally {
                    if (_didIteratorError4) {
                        throw _iteratorError4;
                    }
                }
            }
        }

        /**
         * Unbind handler from event
         *
         * @param {String}   eventName Name of event to unbind from
         * @param {Function} handler   Event handler function to unbind
         */

    }, {
        key: 'off',
        value: function off(eventName, handler) {
            var events = this.getEventList(eventName);

            var _iteratorNormalCompletion5 = true;
            var _didIteratorError5 = false;
            var _iteratorError5 = undefined;

            try {
                for (var _iterator5 = events[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
                    var event = _step5.value;

                    if (!this.events[event]) {
                        return;
                    }

                    var index = this.events[event].indexOf(handler);

                    if (index >= 0) {
                        this.events[event].splice(index, 1);
                    }
                }
            } catch (err) {
                _didIteratorError5 = true;
                _iteratorError5 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion5 && _iterator5.return) {
                        _iterator5.return();
                    }
                } finally {
                    if (_didIteratorError5) {
                        throw _iteratorError5;
                    }
                }
            }
        }

        /**
         * Bind handler to event to run once
         *
         * @param {String}   eventName Name of event to bind to
         * @param {Function} handler   Event handler function to bind
         */

    }, {
        key: 'once',
        value: function once(eventName, handler) {
            function handleOffRemove() {
                this.off(eventName, handler);
                this.off(eventName, handleOffRemove);
            }

            this.on(eventName, handler);
            this.on(eventName, handleOffRemove);
        }

        // endregion Controls

    }]);

    return EventAbstractClass;
}();

exports.default = EventAbstractClass;