awv3/core/events.js

⚡ AWV3 embedded CAD

'use strict';

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

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

var _entries = require('babel-runtime/core-js/object/entries');

var _entries2 = _interopRequireDefault(_entries);

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

var _getIterator2 = require('babel-runtime/core-js/get-iterator');

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Events = function () {
    function Events() {
        (0, _classCallCheck3.default)(this, Events);

        this._callbacks = undefined;
        this._inspectors = undefined;
    }

    (0, _createClass3.default)(Events, [{
        key: 'once',
        value: function once(type, callback) {
            this.on(type, callback, true);
        }
    }, {
        key: 'onFirst',
        value: function onFirst(type, callback) {
            this.on(type, callback, false, 1);
        }
    }, {
        key: 'onLast',
        value: function onLast(type, callback) {
            this.on(type, callback, false, -1);
        }
    }, {
        key: 'on',
        value: function on() {
            var arg1 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
            var arg2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
            var remove = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
            var priority = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;

            if (!this._callbacks) this._callbacks = {};
            if (Array.isArray(arg1) || typeof arg1 === 'string' && typeof arg2 === 'function') {

                // Types & Callback
                var types = Array.isArray(arg1) ? arg1 : [arg1];
                var _iteratorNormalCompletion = true;
                var _didIteratorError = false;
                var _iteratorError = undefined;

                try {
                    for (var _iterator = (0, _getIterator3.default)(types), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                        var type = _step.value;

                        var listeners = this._callbacks[type];
                        if (!listeners) listeners = this._callbacks[type] = [];

                        if (listeners.indexOf(arg2) < 0) {
                            arg2.remove = remove;
                            if (priority) arg2.priority = priority;
                            listeners.push(arg2);
                            listeners.sort(function (a, b) {
                                return b.priority || 0 - a.priority || 0;
                            });

                            if (this._inspectors) {
                                var _iteratorNormalCompletion2 = true;
                                var _didIteratorError2 = false;
                                var _iteratorError2 = undefined;

                                try {
                                    for (var _iterator2 = (0, _getIterator3.default)(this._inspectors), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                                        var inspector = _step2.value;

                                        inspector({ action: 'Add', type: type, callback: arg2 });
                                    }
                                } 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;
                        }
                    }
                }
            } else if ((typeof arg1 === 'undefined' ? 'undefined' : (0, _typeof3.default)(arg1)) === 'object' && arg2 === undefined) {

                // Array of 'Type: Callback' pairs
                for (var key in arg1) {
                    var callback = arg1[key];
                    typeof callback === 'function' && this.on(key, callback, remove, priority);
                }
            }

            return this;
        }
    }, {
        key: 'inspect',
        value: function inspect(callback) {
            if (!this._inspectors) this._inspectors = [];
            this._inspectors.push(callback);
        }
    }, {
        key: 'removeListener',
        value: function removeListener(types, callback) {
            if (!Array.isArray(types) && (typeof types === 'undefined' ? 'undefined' : (0, _typeof3.default)(types)) === 'object' && callback === undefined) {
                // Object of 'Type: Callback'
                var _iteratorNormalCompletion3 = true;
                var _didIteratorError3 = false;
                var _iteratorError3 = undefined;

                try {
                    for (var _iterator3 = (0, _getIterator3.default)((0, _entries2.default)(types)), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                        var _step3$value = (0, _slicedToArray3.default)(_step3.value, 2),
                            type = _step3$value[0],
                            _callback = _step3$value[1];

                        this.removeListener(type, _callback);
                    }
                } catch (err) {
                    _didIteratorError3 = true;
                    _iteratorError3 = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion3 && _iterator3.return) {
                            _iterator3.return();
                        }
                    } finally {
                        if (_didIteratorError3) {
                            throw _iteratorError3;
                        }
                    }
                }

                return this;
            }
            if (!this._callbacks) this._callbacks = {};
            types = Array.isArray(types) ? types : [types];
            var _iteratorNormalCompletion4 = true;
            var _didIteratorError4 = false;
            var _iteratorError4 = undefined;

            try {
                for (var _iterator4 = (0, _getIterator3.default)(types), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
                    var type = _step4.value;

                    var listeners = this._callbacks[type];
                    if (!listeners) continue;
                    if (!callback) {
                        delete this._callbacks[type];
                        if (this._inspectors) {
                            var _iteratorNormalCompletion5 = true;
                            var _didIteratorError5 = false;
                            var _iteratorError5 = undefined;

                            try {
                                for (var _iterator5 = (0, _getIterator3.default)(this._inspectors), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
                                    var inspector = _step5.value;

                                    inspector({ action: 'Remove', type: type, callback: undefined });
                                }
                            } catch (err) {
                                _didIteratorError5 = true;
                                _iteratorError5 = err;
                            } finally {
                                try {
                                    if (!_iteratorNormalCompletion5 && _iterator5.return) {
                                        _iterator5.return();
                                    }
                                } finally {
                                    if (_didIteratorError5) {
                                        throw _iteratorError5;
                                    }
                                }
                            }
                        }
                    } else {
                        var index = listeners.indexOf(callback);
                        index > -1 && listeners.splice(index, 1);
                        if (this._inspectors) {
                            var _iteratorNormalCompletion6 = true;
                            var _didIteratorError6 = false;
                            var _iteratorError6 = undefined;

                            try {
                                for (var _iterator6 = (0, _getIterator3.default)(this._inspectors), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
                                    var _inspector = _step6.value;

                                    _inspector({ action: 'Remove', type: type, callback: callback });
                                }
                            } catch (err) {
                                _didIteratorError6 = true;
                                _iteratorError6 = err;
                            } finally {
                                try {
                                    if (!_iteratorNormalCompletion6 && _iterator6.return) {
                                        _iterator6.return();
                                    }
                                } finally {
                                    if (_didIteratorError6) {
                                        throw _iteratorError6;
                                    }
                                }
                            }
                        }
                    }
                }
            } catch (err) {
                _didIteratorError4 = true;
                _iteratorError4 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion4 && _iterator4.return) {
                        _iterator4.return();
                    }
                } finally {
                    if (_didIteratorError4) {
                        throw _iteratorError4;
                    }
                }
            }

            return this;
        }
    }, {
        key: 'removeListeners',
        value: function removeListeners() {
            this._callbacks = undefined;
        }
    }, {
        key: 'removeInspectors',
        value: function removeInspectors() {
            this._inspectors = undefined;
        }
    }, {
        key: 'emit',
        value: function emit(type) {
            var _this = this;

            for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                args[_key - 1] = arguments[_key];
            }

            var sequence = _promise2.default.resolve();
            if (!this._callbacks) this._callbacks = {};
            var listeners = this._callbacks[type];
            if (!!listeners) {
                var _iteratorNormalCompletion7 = true;
                var _didIteratorError7 = false;
                var _iteratorError7 = undefined;

                try {
                    var _loop = function _loop() {
                        var listener = _step7.value;

                        sequence = sequence.then(function (_) {
                            listener.remove && _this.removeListener(type, listener);
                            return listener.call.apply(listener, [_this].concat(args));
                        });
                    };

                    for (var _iterator7 = (0, _getIterator3.default)(listeners), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
                        _loop();
                    }
                } catch (err) {
                    _didIteratorError7 = true;
                    _iteratorError7 = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion7 && _iterator7.return) {
                            _iterator7.return();
                        }
                    } finally {
                        if (_didIteratorError7) {
                            throw _iteratorError7;
                        }
                    }
                }
            }
            return sequence;
        }
    }, {
        key: 'bubble',
        value: function bubble(type) {
            var _this2 = this;

            for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
                args[_key2 - 1] = arguments[_key2];
            }

            var sequence = _promise2.default.resolve();
            if (!this._callbacks) this._callbacks = {};
            var listeners = this._callbacks[type];
            if (!!listeners) {
                var _iteratorNormalCompletion8 = true;
                var _didIteratorError8 = false;
                var _iteratorError8 = undefined;

                try {
                    var _loop2 = function _loop2() {
                        var listener = _step8.value;

                        sequence = sequence.then(function (_) {
                            return listener.call.apply(listener, [_this2].concat(args));
                        });
                    };

                    for (var _iterator8 = (0, _getIterator3.default)(listeners), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
                        _loop2();
                    }
                } catch (err) {
                    _didIteratorError8 = true;
                    _iteratorError8 = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion8 && _iterator8.return) {
                            _iterator8.return();
                        }
                    } finally {
                        if (_didIteratorError8) {
                            throw _iteratorError8;
                        }
                    }
                }
            } else if (!!this.parent) {
                var _parent;

                // No listener found, just bubble up ...
                (_parent = this.parent).bubble.apply(_parent, [type].concat(args));
            }
            return sequence;
        }
    }, {
        key: 'findListener',
        value: function findListener(type) {
            if (!this._callbacks) this._callbacks = {};
            var listeners = this._callbacks[type];
            if (!!listeners) {
                return this;
            } else if (!!this.parent) {
                // No listener found, just bubble up ...
                return this.parent.find(type);
            }
            return undefined;
        }
    }, {
        key: 'hasListener',
        value: function hasListener(type) {
            var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;

            if (!this._callbacks) this._callbacks = {};
            var listener = this._callbacks[type];
            return !!listener && (!callback || callback === listener);
        }
    }], [{
        key: 'mixin',
        value: function mixin(object) {
            var handlers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

            object.hasListener = Events.prototype.hasListener;
            object.on = Events.prototype.on;
            object.once = Events.prototype.once;
            object.onFirst = Events.prototype.onFirst;
            object.onLast = Events.prototype.onLast;
            object.inspect = Events.prototype.inspect;
            object.removeListener = Events.prototype.removeListener;
            object.removeListeners = Events.prototype.removeListeners;
            object.removeInspectors = Events.prototype.removeInspectors;
            object.emit = Events.prototype.emit;
            object.bubble = Events.prototype.bubble;
            object.findListener = Events.prototype.findListener;
            if (handlers) object.on.bind(object)(handlers);
        }
    }]);
    return Events;
}();

exports.default = Events;