events.js

/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

/* global varienEvents */
/* eslint-disable strict */
define([
    'Magento_Ui/js/modal/alert',
    'prototype'
], function (alert) {
    // from http://www.someelement.com/2007/03/eventpublisher-custom-events-la-pubsub.html
    window.varienEvents = Class.create();

    varienEvents.prototype = {
        /**
         * Initialize.
         */
        initialize: function () {
            this.arrEvents = {};
            this.eventPrefix = '';
        },

        /**
        * Attaches a {handler} function to the publisher's {eventName} event for execution upon the event firing
        * @param {String} eventName
        * @param {Function} handler
        * @param {Boolean} [asynchFlag] - Defaults to false if omitted.
        * Indicates whether to execute {handler} asynchronously (true) or not (false).
        */
        attachEventHandler: function (eventName, handler) {
            var asynchVar, handlerObj;

            if (typeof handler == 'undefined' || handler == null) {
                return;
            }
            eventName += this.eventPrefix;
            // using an event cache array to track all handlers for proper cleanup
            if (this.arrEvents[eventName] == null) {
                this.arrEvents[eventName] = [];
            }
            //create a custom object containing the handler method and the asynch flag
            asynchVar = arguments.length > 2 ? arguments[2] : false;
            handlerObj = {
                method: handler,
                asynch: asynchVar
            };
            this.arrEvents[eventName].push(handlerObj);
        },

        /**
        * Removes a single handler from a specific event
        * @param {String} eventName - The event name to clear the handler from
        * @param {Function} handler - A reference to the handler function to un-register from the event
        */
        removeEventHandler: function (eventName, handler) {
            eventName += this.eventPrefix;

            if (this.arrEvents[eventName] != null) {
                this.arrEvents[eventName] = this.arrEvents[eventName].reject(function (obj) {
                    return obj.method == handler; //eslint-disable-line eqeqeq
                });
            }
        },

        /**
        * Removes all handlers from a single event
        * @param {String} eventName - The event name to clear handlers from
        */
        clearEventHandlers: function (eventName) {
            eventName += this.eventPrefix;
            this.arrEvents[eventName] = null;
        },

        /**
        * Removes all handlers from ALL events
        */
        clearAllEventHandlers: function () {
            this.arrEvents = {};
        },

        /**
         * Collect and modify value of arg synchronously in succession and return its new value.
         * In order to use, call attachEventHandler and add function handlers with eventName.
         * Then call fireEventReducer with eventName and any argument to have its value accumulatively modified.
         * Event handlers will be applied to argument in order of first attached to last attached.
         * @param {String} eventName
         * @param {*} arg
         */
        fireEventReducer: function (eventName, arg) {
            var evtName = eventName + this.eventPrefix,
                result = arg,
                len,
                i;

            if (!this.arrEvents[evtName]) {
                return result;
            }

            len = this.arrEvents[evtName].length; //optimization

            for (i = 0; i < len; i++) {
                /* eslint-disable max-depth */
                try {
                    result = this.arrEvents[evtName][i].method(result);
                } catch (e) {
                    if (this.id) {
                        alert({
                            content: 'error: error in ' + this.id + '.fireEventReducer():\n\nevent name: ' +
                            eventName + '\n\nerror message: ' + e.message
                        });
                    } else {
                        alert({
                            content: 'error: error in [unknown object].fireEventReducer():\n\nevent name: ' +
                            eventName + '\n\nerror message: ' + e.message
                        });
                    }
                }
                /* eslint-disable max-depth */
            }

            return result;
        },

        /**
        * Fires the event {eventName}, resulting in all registered handlers to be executed.
        * It also collects and returns results of all non-asynchronous handlers
        * @param {String} eventName - The name of the event to fire
        * @param {Object} [args] - Any object, will be passed into the handler function as the only argument
        * @return {Array}
        */
        fireEvent: function (eventName) {
            var evtName = eventName + this.eventPrefix,
                results = [],
                result, len, i, eventArgs, method, eventHandler;

            if (this.arrEvents[evtName] != null) {
                len = this.arrEvents[evtName].length; //optimization

                for (i = 0; i < len; i++) {
                    /* eslint-disable max-depth */
                    try {
                        if (arguments.length > 1) {
                            if (this.arrEvents[evtName][i].asynch) {
                                eventArgs = arguments[1];
                                method = this.arrEvents[evtName][i].method.bind(this);
                                setTimeout(function () { //eslint-disable-line no-loop-func
                                    method(eventArgs);
                                }, 10);
                            } else {
                                result = this.arrEvents[evtName][i].method(arguments[1]);
                            }
                        } else {
                            if (this.arrEvents[evtName][i].asynch) { //eslint-disable-line no-lonely-if
                                eventHandler = this.arrEvents[evtName][i].method;
                                setTimeout(eventHandler, 1);
                            } else if (
                                this.arrEvents &&
                                this.arrEvents[evtName] &&
                                this.arrEvents[evtName][i] &&
                                this.arrEvents[evtName][i].method
                            ) {
                                result = this.arrEvents[evtName][i].method();
                            }
                        }
                        results.push(result);
                    }
                    catch (e) {
                        if (this.id) {
                            alert({
                                content: 'error: error in ' + this.id + '.fireEvent():\n\nevent name: ' +
                                eventName + '\n\nerror message: ' + e.message
                            });
                        } else {
                            alert({
                                content: 'error: error in [unknown object].fireEvent():\n\nevent name: ' +
                                eventName + '\n\nerror message: ' + e.message
                            });
                        }
                    }

                    /* eslint-enable max-depth */
                }
            }

            return results;
        }
    };

    window.varienGlobalEvents = new varienEvents(); //jscs:ignore requireCapitalizedConstructors

    return window.varienGlobalEvents;
});