rx-player/dist/commonjs/utils/event_emitter.js

Canal+ HTML5 Video Player

"use strict";
/**
 * Copyright 2015 CANAL+ Group
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
var __values = (this && this.__values) || function(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
        next: function () {
            if (o && i >= o.length) o = void 0;
            return { value: o && o[i++], done: !o };
        }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
Object.defineProperty(exports, "__esModule", { value: true });
var is_null_or_undefined_1 = require("./is_null_or_undefined");
var noop_1 = require("./noop");
/**
 * Simple but fully type-safe EventEmitter implementation.
 * @class EventEmitter
 */
var EventEmitter = /** @class */ (function () {
    function EventEmitter() {
        this._listeners = {};
    }
    /**
     * Register a new callback for an event.
     *
     * @param {string} evt - The event to register a callback to
     * @param {Function} fn - The callback to call as that event is triggered.
     * The callback will take as argument the eventual payload of the event
     * (single argument).
     * @param {Object | undefined} [cancellationSignal] - When that signal emits,
     * the event listener is automatically removed.
     */
    EventEmitter.prototype.addEventListener = function (evt, fn, cancellationSignal) {
        var _this = this;
        var onRemove = noop_1.default;
        if (cancellationSignal !== undefined) {
            if (cancellationSignal.isCancelled()) {
                return;
            }
            var deregister = cancellationSignal.register(function () {
                return _this.removeEventListener(evt, fn);
            });
            onRemove = deregister;
        }
        var listeners = this._listeners[evt];
        if (!Array.isArray(listeners)) {
            this._listeners[evt] = [{ cb: fn, onRemove: onRemove }];
        }
        else {
            listeners.push({ cb: fn, onRemove: onRemove });
        }
    };
    /**
     * Unregister callbacks linked to events.
     * @param {string} [evt] - The event for which the callback[s] should be
     * unregistered. Set it to null or undefined to remove all callbacks
     * currently registered (for any event).
     * @param {Function} [fn] - The callback to unregister. If set to null
     * or undefined while the evt argument is set, all callbacks linked to that
     * event will be unregistered.
     */
    EventEmitter.prototype.removeEventListener = function (evt, fn) {
        var e_1, _a;
        if ((0, is_null_or_undefined_1.default)(evt)) {
            try {
                // Call onRemove for all listeners before clearing
                for (var _b = __values(Object.keys(this._listeners)), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var eventName = _c.value;
                    var listeners_1 = this._listeners[eventName];
                    if (Array.isArray(listeners_1)) {
                        listeners_1.forEach(function (listener) { return listener.onRemove(); });
                    }
                }
            }
            catch (e_1_1) { e_1 = { error: e_1_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_1) throw e_1.error; }
            }
            this._listeners = {};
            return;
        }
        var listeners = this._listeners[evt];
        if (!Array.isArray(listeners)) {
            return;
        }
        if ((0, is_null_or_undefined_1.default)(fn)) {
            listeners.forEach(function (listener) { return listener.onRemove(); });
            delete this._listeners[evt];
            return;
        }
        for (var index = 0; index < listeners.length; index++) {
            if (listeners[index].cb === fn) {
                listeners[index].onRemove();
                listeners.splice(index, 1);
                break;
            }
        }
        if (listeners.length === 0) {
            delete this._listeners[evt];
        }
    };
    /**
     * Trigger every registered callbacks for a given event
     * @param {string} evt - The event to trigger
     * @param {*} arg - The eventual payload for that event. All triggered
     * callbacks will recieve this payload as argument.
     */
    EventEmitter.prototype.trigger = function (evt, arg) {
        var listeners = this._listeners[evt];
        if (!Array.isArray(listeners)) {
            return;
        }
        listeners.slice().forEach(function (listener) {
            try {
                listener.cb(arg);
            }
            catch (e) {
                // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
                if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
                    throw e instanceof Error ? e : new Error("EventEmitter: listener error");
                }
                // Cannot use our logger here sadly because our logger is an `EventEmitter`
                // itself.
                // eslint-disable-next-line no-console
                console.error("RxPlayer: EventEmitter error", e instanceof Error ? e : null);
            }
        });
    };
    return EventEmitter;
}());
exports.default = EventEmitter;