awv3/dist/core/events.js

⚡ AWV3 embedded CAD

'use strict';

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

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

var _promise2 = _interopRequireDefault(_promise);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

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, { remove: true });
        }
    }, {
        key: 'onFirst',
        value: function onFirst(type, callback) {
            this.on(type, callback, { priority: 1 });
        }
    }, {
        key: 'onLast',
        value: function onLast(type, callback) {
            this.on(type, callback, { priority: -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 options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

            if (Array.isArray(arg1)) {
                // (Array of types) & callback
                var _iteratorNormalCompletion = true;
                var _didIteratorError = false;
                var _iteratorError = undefined;

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

                        this.on(type, arg2, options);
                    }
                } 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') {
                // Object with 'Type: Callback' pairs
                if ((typeof arg2 === 'undefined' ? 'undefined' : (0, _typeof3.default)(arg2)) === 'object') options = arg2;
                var _iteratorNormalCompletion2 = true;
                var _didIteratorError2 = false;
                var _iteratorError2 = undefined;

                try {
                    for (var _iterator2 = (0, _getIterator3.default)((0, _entries2.default)(arg1)), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                        var _step2$value = (0, _slicedToArray3.default)(_step2.value, 2),
                            key = _step2$value[0],
                            callback = _step2$value[1];

                        if (typeof callback === 'function') this.on(key, callback, options);
                    }
                } catch (err) {
                    _didIteratorError2 = true;
                    _iteratorError2 = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion2 && _iterator2.return) {
                            _iterator2.return();
                        }
                    } finally {
                        if (_didIteratorError2) {
                            throw _iteratorError2;
                        }
                    }
                }
            } else if (typeof arg1 === 'string' && typeof arg2 === 'function') {
                // Type & Callback
                var _type = arg1,
                    callback = arg2;
                var _options = options,
                    _options$remove = _options.remove,
                    remove = _options$remove === undefined ? false : _options$remove,
                    _options$priority = _options.priority,
                    priority = _options$priority === undefined ? 0 : _options$priority,
                    _options$sync = _options.sync,
                    sync = _options$sync === undefined ? false : _options$sync;


                if (!this._callbacks) this._callbacks = {};
                var listeners = this._callbacks[_type];
                if (!listeners) listeners = this._callbacks[_type] = [];

                // note: do not add duplicate callbacks
                if (listeners.indexOf(callback) < 0) {
                    callback.remove = remove;
                    callback.sync = sync;
                    callback.priority = priority;

                    listeners.push(callback);
                    listeners.sort(function (a, b) {
                        return b.priority - a.priority;
                    });

                    if (this._inspectors) {
                        var _iteratorNormalCompletion3 = true;
                        var _didIteratorError3 = false;
                        var _iteratorError3 = undefined;

                        try {
                            for (var _iterator3 = (0, _getIterator3.default)(this._inspectors), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                                var inspector = _step3.value;

                                inspector({ action: 'Add', type: _type, callback: callback });
                            }
                        } catch (err) {
                            _didIteratorError3 = true;
                            _iteratorError3 = err;
                        } finally {
                            try {
                                if (!_iteratorNormalCompletion3 && _iterator3.return) {
                                    _iterator3.return();
                                }
                            } finally {
                                if (_didIteratorError3) {
                                    throw _iteratorError3;
                                }
                            }
                        }
                    }
                }
            }

            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 _iteratorNormalCompletion4 = true;
                var _didIteratorError4 = false;
                var _iteratorError4 = undefined;

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

                        this.removeListener(type, _callback);
                    }
                } catch (err) {
                    _didIteratorError4 = true;
                    _iteratorError4 = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion4 && _iterator4.return) {
                            _iterator4.return();
                        }
                    } finally {
                        if (_didIteratorError4) {
                            throw _iteratorError4;
                        }
                    }
                }

                return this;
            }
            if (!this._callbacks) this._callbacks = {};
            types = Array.isArray(types) ? types : [types];
            var _iteratorNormalCompletion5 = true;
            var _didIteratorError5 = false;
            var _iteratorError5 = undefined;

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

                    var listeners = this._callbacks[type];
                    if (!listeners) continue;
                    if (!callback) {
                        delete this._callbacks[type];
                        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: undefined });
                                }
                            } catch (err) {
                                _didIteratorError6 = true;
                                _iteratorError6 = err;
                            } finally {
                                try {
                                    if (!_iteratorNormalCompletion6 && _iterator6.return) {
                                        _iterator6.return();
                                    }
                                } finally {
                                    if (_didIteratorError6) {
                                        throw _iteratorError6;
                                    }
                                }
                            }
                        }
                    } else {
                        var index = listeners.indexOf(callback);
                        index > -1 && listeners.splice(index, 1);
                        if (this._inspectors) {
                            var _iteratorNormalCompletion7 = true;
                            var _didIteratorError7 = false;
                            var _iteratorError7 = undefined;

                            try {
                                for (var _iterator7 = (0, _getIterator3.default)(this._inspectors), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
                                    var _inspector = _step7.value;

                                    _inspector({ action: 'Remove', type: type, callback: callback });
                                }
                            } catch (err) {
                                _didIteratorError7 = true;
                                _iteratorError7 = err;
                            } finally {
                                try {
                                    if (!_iteratorNormalCompletion7 && _iterator7.return) {
                                        _iterator7.return();
                                    }
                                } finally {
                                    if (_didIteratorError7) {
                                        throw _iteratorError7;
                                    }
                                }
                            }
                        }
                    }
                }
            } catch (err) {
                _didIteratorError5 = true;
                _iteratorError5 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion5 && _iterator5.return) {
                        _iterator5.return();
                    }
                } finally {
                    if (_didIteratorError5) {
                        throw _iteratorError5;
                    }
                }
            }

            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];
            }

            if (!this._callbacks) this._callbacks = {};
            var listeners = this._callbacks[type];
            //clone listeners array to ensure safe callbacks removal
            listeners = listeners ? [].concat((0, _toConsumableArray3.default)(listeners)) : [];

            //call all synchronous events first;
            var _iteratorNormalCompletion8 = true;
            var _didIteratorError8 = false;
            var _iteratorError8 = undefined;

            try {
                for (var _iterator8 = (0, _getIterator3.default)(listeners), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
                    var listener = _step8.value;

                    if (listener.sync) {
                        if (listener.remove) this.removeListener(type, listener);
                        listener.call.apply(listener, [this].concat(args));
                    }
                } //call all asynchronous events in promise chain
            } catch (err) {
                _didIteratorError8 = true;
                _iteratorError8 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion8 && _iterator8.return) {
                        _iterator8.return();
                    }
                } finally {
                    if (_didIteratorError8) {
                        throw _iteratorError8;
                    }
                }
            }

            var sequence = _promise2.default.resolve();
            var _iteratorNormalCompletion9 = true;
            var _didIteratorError9 = false;
            var _iteratorError9 = undefined;

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

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

                for (var _iterator9 = (0, _getIterator3.default)(listeners), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
                    _loop();
                }
            } catch (err) {
                _didIteratorError9 = true;
                _iteratorError9 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion9 && _iterator9.return) {
                        _iterator9.return();
                    }
                } finally {
                    if (_didIteratorError9) {
                        throw _iteratorError9;
                    }
                }
            }

            return sequence;
        }

        //TODO: does it work properly?
        //what about case when listeners = []

    }, {
        key: 'bubble',
        value: function bubble(type) {
            if (!this._callbacks) this._callbacks = {};
            var listeners = this._callbacks[type];

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

            if (listeners) {
                return this.emit.apply(this, [type].concat(args));
            } else if (this.parent) {
                var _parent;

                // No listener found, just bubble up ...
                return (_parent = this.parent).bubble.apply(_parent, [type].concat(args));
            }
            return _promise2.default.resolve();
        }
    }, {
        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;