Events/Events.js at master · mowses/Events · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
function makeArray(obj) {
    if (Array.isArray(obj)) return obj;

    return [].slice.call([obj]);
}

const Events = function (supported_events) {
    let events = {};

    // add supported events
    [].forEach.call(makeArray(supported_events), function (event) {
        events[event] = {};
    });

    return {
        on: function (arr_events, callback) {
            let parent = this;

            arr_events = makeArray(arr_events);

            [].forEach.call(arr_events, function (event) {
                let event_parts = event.split('.'),
                    event_name = event_parts[0],
                    event_namespace = event_parts.slice(1).join('.');

                if (!events[event_name]) {
                    console.trace(parent, 'does not support "' + event_name + '" event.');
                } else {
                    if (!events[event_name][event_namespace]) {
                        events[event_name][event_namespace] = [];
                    }

                    events[event_name][event_namespace].push(callback);
                }
            });

            return parent;
        },

        once: function (arr_events, callback) {
            arr_events = makeArray(arr_events);

            let parent = this,
                // create a wrapper for 'on' method
                new_callback = function () {
                    // remove new_callback from events
                    [].forEach.call(arr_events, function (event) {

                        let event_parts = event.split('.'),
                            event_name = event_parts[0],
                            event_namespace = event_parts.slice(1).join('.');

                        events[event_name][event_namespace] = events[event_name][event_namespace].filter(function (cb) {
                            return cb !== new_callback;
                        }, true);
                    });

                    // execute the callback after removing new_callback
                    // otherwise it may loop infinitely
                    callback.apply(this, arguments);
                };

            this.on(arr_events, new_callback);

            return parent;
        },

        trigger: function (event, ...params) {
            let parent = this,
                event_parts = event.split('.'),
                event_name = event_parts[0],
                event_namespace = event_parts.slice(1).join('.'),
                callbacks;

            if (!events[event_name]) {
                console.warn(parent, 'does not support "' + event_name + '" event.');
                return parent;
            }

            if (!event_namespace) {
                // trigger all events with event_name because there is no namespace
                callbacks = (function (events) {
                    let callbacks = [];
                    Object.entries(events).forEach(([, items]) => {
                        [].forEach.call(items, function (callback) {
                            callbacks.push(callback);
                        });
                    });

                    return callbacks;

                })(events[event_name]);
            } else {
                callbacks = makeArray(events[event_name][event_namespace]);
            }

            [].forEach.call(callbacks, function (callback) {
                if (typeof callback !== 'function') return;

                callback.apply(parent, params);
            });

            return parent;
        },

        remove: function (arr_events) {
            let parent = this;

            [].forEach.call(makeArray(arr_events), function (event) {

                let event_parts = event.split('.'),
                    event_name = event_parts[0],
                    event_namespace = event_parts.slice(1).join('.');

                if (!event_namespace) {
                    events[event_name] = {};
                } else {
                    events[event_name][event_namespace] = [];
                }

            });

            return parent;
        }
    };
};

export default Events;