@irrelon/emitter 3.0.0 → 5.0.0

package/dist/Emitter.js

@@ -1,853 +1,415 @@
-/*
- The MIT License (MIT)
-
- Copyright (c) 2014 Irrelon Software Limited
- http://www.irrelon.com
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice, url and this permission notice shall be included in
- all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE.
-
- Source: https://github.com/irrelon/emitter
-
- Changelog:
- 	Version 2.0.11:
- 		Added cancelStatic method to allow cancelling a static event
- 	Version 2.0.7:
- 		Fixed UMD module support
- 	Version 2.0.6:
- 		Added UMD module support
- 	Version 2.0.5:
- 		Added bower version number
- 	Version 2.0.4:
- 		Allow instantiation as independent instance, updated unit tests
- 	Version 2.0.3:
- 		Documentation updates, published to bower
- 	Version 2.0.2:
- 		Documentation updates
- 	Version 2.0.1:
- 		Bug fix in this._emitters usage
- 	Version 2.0.0:
- 		Big update to bring in line with latest developments in other projects. Event emitter can
- 		now use deferEmit(), emitId(), emitStatic(), emitStaticId(), willEmit(), willEmitId().
- 	Version 1.1.9:
- 		Updated changelog correctly
- 	Version 1.1.8:
- 		Removed tons of dependencies wrongly included in main dependencies, have moved to devDependencies section of package.json
- 	Version 1.1.0:
- 		Added support for overloaded methods
- 		Added support for events with ids
- 	Version 1.0.2:
- 		Removed AMD support, added browserify support
- 		Added package.json
- 		Added once() method
- 		Added hasListener() method
- 		Published to NPM as irrelon-emitter
- 	Version 1.0.1:
- 		Added ability to extend any object with eventing capability
- 		Added AMD / Require.js support
-		 Added Node.js support
-	Version 1.0.0:
-		First commit
- */
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-
-var Overload = require("irrelon-overload");
-
-var EventMethods = {
-  on: new Overload({
-    /**
-     * Attach an event listener to the passed event.
-     * @memberof Emitter
-     * @method on
-     * @param {String} event The name of the event to listen for.
-     * @param {Function} listener The method to call when the event is fired.
-     */
-    "string, function": function stringFunction(event, listener) {
-      return this.$main(event, "*", listener);
-    },
-
-    /**
-     * Attach an event listener to the passed event only if the passed
-     * id matches the document id for the event being fired.
-     * @memberof Emitter
-     * @method on
-     * @param {String} event The name of the event to listen for.
-     * @param {*} id The document id to match against.
-     * @param {Function} listener The method to call when the event is fired.
-     */
-    "string, *, function": function stringFunction(event, id, listener) {
-      return this.$main(event, id, listener);
-    },
-
-    /**
-     * @param event
-     * @param id
-     * @param listener
-     * @return {$main}
-     * @private
-     */
-    "$main": function $main(event, id, listener) {
-      var self = this,
-          generateTimeout,
-          emitter,
-          i;
-
-      generateTimeout = function generateTimeout(emitter) {
-        setTimeout(function () {
-          listener.apply(self, emitter.args);
-        }, 1);
-      };
-
-      this._listeners = this._listeners || {};
-      this._listeners[event] = this._listeners[event] || {};
-      this._listeners[event][id] = this._listeners[event][id] || [];
-
-      this._listeners[event][id].push(listener); // Check for any static emitters, and fire the event if any exist
-
-
-      if (this._emitters && this._emitters[event] && this._emitters[event].length) {
-        // Emit events for each emitter
-        for (i = 0; i < this._emitters[event].length; i++) {
-          emitter = this._emitters[event];
-
-          if (id === "*" || emitter.id === id) {
-            // Call the listener out of process so that any code that expects a listener
-            // to be called at some point in the future rather than immediately on registration
-            // will not fail
-            generateTimeout(emitter);
-          }
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEmitter = exports.Emitter = void 0;
+/**
+ * @class Emitter
+ * @constructor
+ */
+class Emitter {
+    constructor(obj) {
+        this._noEmitDefer = false;
+        this._emitting = false;
+        this._listeners = {};
+        this._emitters = {};
+        this._eventRemovalQueue = [];
+        if (obj !== undefined) {
+            return (0, exports.makeEmitter)(obj);
         }
-      }
-
-      return this;
     }
-  }),
-  once: new Overload({
-    /**
-     * Attach an event listener to the passed event which will only fire once.
-     * @memberof Emitter
-     * @method once
-     * @param {String} event The name of the event to listen for.
-     * @param {Function} listener The method to call when the event is fired.
-     */
-    "string, function": function stringFunction(event, listener) {
-      var self = this,
-          fired = false,
-          internalCallback = function internalCallback() {
-        if (!fired) {
-          fired = true;
-          self.off(event, internalCallback);
-          listener.apply(self, arguments);
-        }
-      };
-
-      return this.on(event, internalCallback);
-    },
-
     /**
      * Attach an event listener to the passed event only if the passed
      * id matches the document id for the event being fired.
-     * @memberof Emitter
-     * @method once
+     * @memberOf Emitter
+     * @method on
      * @param {String} event The name of the event to listen for.
      * @param {*} id The document id to match against.
      * @param {Function} listener The method to call when the event is fired.
+     * @returns {Emitter} The emitter instance.
      */
-    "string, *, function": function stringFunction(event, id, listener) {
-      var self = this,
-          fired = false,
-          internalCallback = function internalCallback() {
-        if (!fired) {
-          fired = true;
-          self.off(event, id, internalCallback);
-          listener.apply(self, arguments);
-        }
-      };
-
-      return this.on(event, id, internalCallback);
+    _on(event, id, listener) {
+        const generateEmitterTimeout = (emitter) => {
+            setTimeout(() => {
+                listener.apply(this, emitter.args);
+            }, 1);
+        };
+        this._listeners = this._listeners || {};
+        this._listeners[event] = this._listeners[event] || {};
+        this._listeners[event][id] = this._listeners[event][id] || [];
+        this._listeners[event][id].push(listener);
+        // Check for any static emitters, and fire the event if any exist
+        if (!this._emitters || !this._emitters[event] || !this._emitters[event].length)
+            return this;
+        // Emit events for each emitter
+        this._emitters[event].forEach((emitter) => {
+            if (id === "*" || emitter.id === id) {
+                // Call the listener out of process so that any code that expects a listener
+                // to be called at some point in the future rather than immediately on registration
+                // will not fail
+                generateEmitterTimeout(emitter);
+            }
+        });
+        return this;
     }
-  }),
-  one: new Overload({
-    /**
-     * Attach an event listener to the passed event which will cancel all
-     * previous listeners and only fire this newest one.
-     * @memberof Emitter
-     * @method one
-     * @param {String} event The name of the event to listen for.
-     * @param {Function} listener The method to call when the event is fired.
-     */
-    "string, function": function stringFunction(event, listener) {
-      this.off(event);
-      return this.on(event, listener);
-    },
-
     /**
      * Attach an event listener to the passed event only if the passed
      * id matches the document id for the event being fired.
-     * @memberof Emitter
+     * @memberOf Emitter
      * @method once
      * @param {String} event The name of the event to listen for.
      * @param {*} id The document id to match against.
      * @param {Function} listener The method to call when the event is fired.
+     * @returns {Emitter} The emitter instance.
      */
-    "string, *, function": function stringFunction(event, id, listener) {
-      this.off(event, id);
-      return this.on(event, id, listener);
+    _once(event, id, listener) {
+        let fired = false;
+        const internalCallback = (...rest) => {
+            if (fired)
+                return;
+            fired = true;
+            this.off(event, id, internalCallback);
+            listener(...rest);
+        };
+        return this.on(event, id, internalCallback);
     }
-  }),
-  off: new Overload({
-    /**
-     * Cancels all event listeners for the passed event.
-     * @memberof Emitter
-     * @method off
-     * @param {String} event The name of the event.
-     * @returns {*}
-     */
-    "string": function string(event) {
-      var self = this;
-
-      if (this._emitting) {
-        this._eventRemovalQueue = this._eventRemovalQueue || [];
-
-        this._eventRemovalQueue.push(function () {
-          self.off(event);
-        });
-      } else {
-        if (this._listeners && this._listeners[event]) {
-          delete this._listeners[event];
-        }
-      }
-
-      return this;
-    },
-
-    /**
-     * Cancels the event listener for the passed event and listener function.
-     * @memberof Emitter
-     * @method off
-     * @param {String} event The event to cancel listener for.
-     * @param {Function} listener The event listener function used in the on()
-     * or once() call to cancel.
-     * @returns {*}
-     */
-    "string, function": function stringFunction(event, listener) {
-      var self = this,
-          arr,
-          index;
-
-      if (this._emitting) {
-        this._eventRemovalQueue = this._eventRemovalQueue || [];
-
-        this._eventRemovalQueue.push(function () {
-          self.off(event, listener);
-        });
-      } else {
-        if (typeof listener === "string") {
-          if (this._listeners && this._listeners[event] && this._listeners[event][listener]) {
-            delete this._listeners[event][listener];
-          }
-        } else {
-          if (this._listeners && this._listeners[event]) {
-            arr = this._listeners[event]["*"] || [];
-            index = arr.indexOf(listener);
-
-            if (index > -1) {
-              arr.splice(index, 1);
-            }
-          }
-        }
-      }
-
-      return this;
-    },
-
     /**
      * Cancels an event listener based on an event name, id and listener function.
-     * @memberof Emitter
+     * @memberOf Emitter
      * @method off
      * @param {String} event The event to cancel listener for.
      * @param {String} id The ID of the event to cancel listening for.
      * @param {Function} listener The event listener function used in the on()
      * or once() call to cancel.
+     * @returns {Emitter} The emitter instance.
      */
-    "string, *, function": function stringFunction(event, id, listener) {
-      var self = this;
-
-      if (this._emitting) {
-        this._eventRemovalQueue = this._eventRemovalQueue || [];
-
-        this._eventRemovalQueue.push(function () {
-          self.off(event, id, listener);
-        });
-      } else {
-        if (this._listeners && this._listeners[event] && this._listeners[event][id]) {
-          var arr = this._listeners[event][id] || [],
-              index = arr.indexOf(listener);
-
-          if (index > -1) {
+    _off(event, id, listener) {
+        if (this._emitting) {
+            this._eventRemovalQueue = this._eventRemovalQueue || [];
+            this._eventRemovalQueue.push(() => {
+                this.off(event, id, listener);
+            });
+            return this;
+        }
+        if (!this._listeners || !this._listeners[event] || !this._listeners[event][id])
+            return this;
+        if (id && !listener) {
+            if (id === "*") {
+                delete this._listeners[event];
+                return this;
+            }
+            // No listener provided, delete all listeners
+            delete this._listeners[event][id];
+            return this;
+        }
+        if (!listener)
+            return this;
+        const arr = this._listeners[event][id] || [];
+        const index = arr.indexOf(listener);
+        if (index > -1) {
             arr.splice(index, 1);
-          }
         }
-      }
-    },
-
-    /**
-     * Cancels all listeners for an event based on the passed event name and id.
-     * @memberof Emitter
-     * @method off
-     * @param {String} event The event name to cancel listeners for.
-     * @param {*} id The ID to cancel all listeners for.
-     */
-    "string, *": function string(event, id) {
-      var self = this;
-
-      if (this._emitting) {
-        this._eventRemovalQueue = this._eventRemovalQueue || [];
-
-        this._eventRemovalQueue.push(function () {
-          self.off(event, id);
-        });
-      } else {
-        if (this._listeners && this._listeners[event] && this._listeners[event][id]) {
-          // Kill all listeners for this event id
-          delete this._listeners[event][id];
+    }
+    on(event, ...rest) {
+        const restTypes = rest.map((arg) => typeof arg);
+        if (restTypes[0] === "function") {
+            return this._on.call(this, event, "*", rest[0]);
         }
-      }
+        return this._on.call(this, event, rest[0], rest[1]);
+    }
+    once(event, ...rest) {
+        const restTypes = rest.map((arg) => typeof arg);
+        if (restTypes[0] === "function") {
+            return this._once.call(this, event, "*", rest[0]);
+        }
+        return this._once.call(this, event, rest[0], rest[1]);
+    }
+    one(event, ...rest) {
+        const restTypes = rest.map((arg) => typeof arg);
+        if (restTypes[0] === "function") {
+            this.off(event);
+            return this._on.call(this, event, "*", rest[0]);
+        }
+        this.off(event, rest[0]);
+        return this._on.call(this, event, rest[0], rest[1]);
+    }
+    off(event, ...rest) {
+        if (rest.length === 0) {
+            // Only event was provided
+            return this._off.call(this, event, "*");
+        }
+        const restTypes = rest.map((arg) => typeof arg);
+        if (restTypes[0] === "function") {
+            return this._off.call(this, event, "*", rest[0]);
+        }
+        return this._off.call(this, event, rest[0], rest[1]);
     }
-  }),
-  emit: new Overload({
-    /**
-     * Emit an event.
-     * @memberof Emitter
-     * @method emit
-     * @param {String} event The event to emit.
-     * @returns {*}
-     */
-    "string": function string(event) {
-      // Fire global listeners
-      return this.$main(event);
-    },
-
-    /**
-     * Emit an event with data.
-     * @memberof Emitter
-     * @method emit
-     * @param {String} event The event to emit.
-     * @param {*} data Data to emit with the event.
-     * @returns {*}
-     */
-    "string, ...": function string(event, data) {
-      // Fire global listeners first
-      this.$main.apply(this, arguments);
-      return this;
-    },
-
     /**
      * Handles emitting events, is an internal method not called directly.
      * @param {String} event The name of the event to emit.
      * @param {*} data The data to emit with the event.
-     * @returns {*}
+     * @returns {Emitter} The emitter instance.
      * @private
      */
-    "$main": function $main(event, data) {
-      var id = "*";
-      this._listeners = this._listeners || {};
-      this._emitting = true;
-
-      if (this._listeners[event]) {
-        var arrIndex, arrCount, tmpFunc, arr; // Handle global emit
-
-        if (this._listeners[event][id]) {
-          arr = this._listeners[event][id];
-          arrCount = arr.length;
-
-          for (arrIndex = 0; arrIndex < arrCount; arrIndex++) {
-            // Check we have a function to execute
-            tmpFunc = arr[arrIndex];
-
-            if (typeof tmpFunc === "function") {
-              tmpFunc.apply(this, Array.prototype.slice.call(arguments, 1));
+    emit(event, ...data) {
+        const id = "*";
+        this._listeners = this._listeners || {};
+        this._emitting = true;
+        if (this._listeners[event] && this._listeners[event][id]) {
+            // Handle global emit
+            const arr = this._listeners[event][id];
+            const arrCount = arr.length;
+            for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
+                // Check we have a function to execute
+                const tmpFunc = arr[arrIndex];
+                if (typeof tmpFunc === "function") {
+                    tmpFunc.call(this, ...data);
+                }
             }
-          }
         }
-      }
-
-      this._emitting = false;
-
-      this._processRemovalQueue();
-
-      return this;
+        this._emitting = false;
+        this._processRemovalQueue();
+        return this;
     }
-  }),
-  emitId: new Overload({
-    "string": function string(event) {
-      throw "Missing id from emitId call!";
-    },
-    "string, *": function string(event, id) {
-      return this.$main(event, id);
-    },
-    "string, *, ...": function string(event, id) {
-      // Fire global listeners first
-      this.$main.apply(this, arguments);
-      return this;
-    },
-    "$main": function $main(event, id, data) {
-      this._listeners = this._listeners || {};
-      this._emitting = true;
-
-      if (this._listeners[event]) {
-        var arrIndex, arrCount, tmpFunc, arr; // Handle global emit
-
-        if (this._listeners[event]["*"]) {
-          arr = this._listeners[event]["*"];
-          arrCount = arr.length;
-
-          for (arrIndex = 0; arrIndex < arrCount; arrIndex++) {
-            // Check we have a function to execute
-            tmpFunc = arr[arrIndex];
-
-            if (typeof tmpFunc === "function") {
-              tmpFunc.apply(this, Array.prototype.slice.call(arguments, 2));
-            }
-          }
-        } // Handle id emit
-
-
+    emitId(event, id, ...data) {
+        this._listeners = this._listeners || {};
+        this._emitting = true;
+        if (!this._listeners || !this._listeners[event]) {
+            this._emitting = false;
+            this._processRemovalQueue();
+            return this;
+        }
+        // Handle id emit
         if (this._listeners[event][id]) {
-          arr = this._listeners[event][id];
-          arrCount = arr.length;
-
-          for (arrIndex = 0; arrIndex < arrCount; arrIndex++) {
-            // Check we have a function to execute
-            tmpFunc = arr[arrIndex];
-
-            if (typeof tmpFunc === "function") {
-              tmpFunc.apply(this, Array.prototype.slice.call(arguments, 2));
+            const arr = this._listeners[event][id];
+            const arrCount = arr.length;
+            for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
+                // Check we have a function to execute
+                const tmpFunc = arr[arrIndex];
+                if (typeof tmpFunc === "function") {
+                    tmpFunc.call(this, ...data);
+                }
             }
-          }
         }
-      }
-
-      this._emitting = false;
-
-      this._processRemovalQueue();
-
-      return this;
+        // Handle global emit
+        if (this._listeners[event]["*"]) {
+            const arr = this._listeners[event]["*"];
+            const arrCount = arr.length;
+            for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
+                // Check we have a function to execute
+                const tmpFunc = arr[arrIndex];
+                if (typeof tmpFunc === "function") {
+                    tmpFunc.call(this, ...data);
+                }
+            }
+        }
+        this._emitting = false;
+        this._processRemovalQueue();
+        return this;
     }
-  }),
-  emitStatic: new Overload({
     /**
-     * Emit an event that will fire on listeners even when the listener
-     * is registered AFTER the event has been emitted.
-     * @memberof Emitter
-     * @method emitStatic
-     * @param {String} event The event to emit.
-     * @returns {*}
-     */
-    "string": function string(event) {
-      // Fire global listeners
-      return this.$main(event);
-    },
-
-    /**
-     * Emit an event with data that will fire on listeners even when the listener
-     * is registered AFTER the event has been emitted.
-     * @memberof Emitter
-     * @method emitStatic
-     * @param {String} event The event to emit.
-     * @param {*} data Data to emit with the event.
-     * @returns {*}
-     */
-    "string, ...": function string(event, data) {
-      // Fire global listeners first
-      this.$main.apply(this, arguments);
-      return this;
-    },
-
-    /**
-     * Handles emitting events, is an internal method not called directly.
+     * Creates a static event emitter that is emitted whenever an
+     * event listener is created with the same name.
      * @param {String} event The name of the event to emit.
      * @param {*} data The data to emit with the event.
-     * @returns {*}
-     * @private
+     * @returns {Emitter} The emitter instance.
      */
-    "$main": function $main(event, data) {
-      var id = "*";
-      this._listeners = this._listeners || {};
-      this._emitting = true;
-
-      if (this._listeners[event]) {
-        var arrIndex, arrCount, tmpFunc, arr; // Handle global emit
-
-        if (this._listeners[event][id]) {
-          arr = this._listeners[event][id];
-          arrCount = arr.length;
-
-          for (arrIndex = 0; arrIndex < arrCount; arrIndex++) {
-            // Check we have a function to execute
-            tmpFunc = arr[arrIndex];
-
-            if (typeof tmpFunc === "function") {
-              tmpFunc.apply(this, Array.prototype.slice.call(arguments, 1));
-            }
-          }
-        }
-      }
-
-      this._emitting = false;
-      this._emitters = this._emitters || {};
-      this._emitters[event] = this._emitters[event] || [];
-
-      this._emitters[event].push({
-        id: "*",
-        args: Array.prototype.slice.call(arguments, 1)
-      });
-
-      this._processRemovalQueue();
-
-      return this;
+    emitStatic(event, ...data) {
+        this._emitters = this._emitters || {};
+        this._emitters[event] = this._emitters[event] || [];
+        this._emitters[event].push({
+            "id": "*",
+            "args": data
+        });
+        this.emit(event, ...data);
+        this._processRemovalQueue();
+        return this;
     }
-  }),
-  emitStaticId: new Overload({
-    /**
-     * Require an id to emit.
-     * @memberof Emitter
-     * @method emitStaticId
-     * @param event
-     */
-    "string": function string(event) {
-      throw "Missing id from emitId call!";
-    },
-
     /**
-     * Emit an event that will fire on listeners even when the listener
-     * is registered AFTER the event has been emitted.
-     * @memberof Emitter
-     * @method emitStaticId
-     * @param {String} event The event to emit.
+     * Creates a static event emitter that is emitted whenever an
+     * event listener is created with the same name and id.
+     * @param {String} event The name of the event to emit.
      * @param {String} id The id of the event to emit.
-     * @returns {*}
+     * @param {*} data The data to emit with the event.
+     * @returns {Emitter} The emitter instance.
      */
-    "string, *": function string(event, id) {
-      return this.$main(event, id);
-    },
-
+    emitStaticId(event, id, ...data) {
+        if (!id)
+            throw new Error("Missing id from emitStaticId call!");
+        this._emitters = this._emitters || {};
+        this._emitters[event] = this._emitters[event] || [];
+        this._emitters[event].push({
+            id,
+            "args": data
+        });
+        this.emitId(event, id, ...data);
+        return this;
+    }
     /**
-     * Emit an event that will fire on listeners even when the listener
-     * is registered AFTER the event has been emitted.
-     * @memberof Emitter
-     * @method emitStaticId
-     * @param {String} event The event to emit.
-     * @param {String} id The id of the event to emit.
-     * @param {*=} data The data to emit with the event.
-     * @returns {*}
+     * Handles removing emitters, is an internal method not called directly.
+     * @param {String} event The event to remove static emitter for.
+     * @returns {Emitter} The emitter instance.
+     * @private
      */
-    "string, *, ...": function string(event, id, data) {
-      // Fire global listeners first
-      this.$main.apply(this, arguments);
-      return this;
-    },
-
+    cancelStatic(event) {
+        this._emitters = this._emitters || {};
+        this._emitters[event] = [];
+        return this;
+    }
     /**
-     * Handles emitting events, is an internal method not called directly.
-     * @param {String} event The name of the event to emit.
-     * @param {String} id The id of the event to emit.
-     * @param {*} data The data to emit with the event.
-     * @returns {*}
-     * @private
+     * Checks if an event has any event listeners or not.
+     * @memberOf Emitter
+     * @method willEmit
+     * @param {String} event The name of the event to check for.
+     * @returns {boolean} True if one or more event listeners are registered for
+     * the event. False if none are found.
      */
-    "$main": function $main(event, id, data) {
-      this._listeners = this._listeners || {};
-      this._emitting = true;
-
-      if (this._listeners[event]) {
-        var arrIndex, arrCount, tmpFunc, arr; // Handle global emit
-
-        if (this._listeners[event]["*"]) {
-          arr = this._listeners[event]["*"];
-          arrCount = arr.length;
-
-          for (arrIndex = 0; arrIndex < arrCount; arrIndex++) {
+    willEmit(event) {
+        const id = "*";
+        if (!this._listeners || !this._listeners[event]) {
+            return false;
+        }
+        const arr = this._listeners[event][id];
+        const arrCount = arr.length;
+        for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
             // Check we have a function to execute
-            tmpFunc = arr[arrIndex];
-
+            const tmpFunc = arr[arrIndex];
             if (typeof tmpFunc === "function") {
-              tmpFunc.apply(this, Array.prototype.slice.call(arguments, 2));
+                return true;
             }
-          }
-        } // Handle id emit
-
-
+        }
+        return false;
+    }
+    /**
+     * Checks if an event has any event listeners or not based on the passed id.
+     * @memberOf Emitter
+     * @method willEmitId
+     * @param {String} event The name of the event to check for.
+     * @param {String} id The event ID to check for.
+     * @returns {boolean} True if one or more event listeners are registered for
+     * the event. False if none are found.
+     */
+    willEmitId(event, id) {
+        if (!this._listeners || !this._listeners[event]) {
+            return false;
+        }
+        // Handle id emit
         if (this._listeners[event][id]) {
-          arr = this._listeners[event][id];
-          arrCount = arr.length;
-
-          for (arrIndex = 0; arrIndex < arrCount; arrIndex++) {
-            // Check we have a function to execute
-            tmpFunc = arr[arrIndex];
-
-            if (typeof tmpFunc === "function") {
-              tmpFunc.apply(this, Array.prototype.slice.call(arguments, 2));
+            const arr = this._listeners[event][id];
+            const arrCount = arr.length;
+            for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
+                // Check we have a function to execute
+                const tmpFunc = arr[arrIndex];
+                if (typeof tmpFunc === "function") {
+                    return true;
+                }
             }
-          }
         }
-      }
-
-      this._emitting = false;
-      this._emitters = this._emitters || {};
-      this._emitters[event] = this._emitters[event] || [];
-
-      this._emitters[event].push({
-        id: id,
-        args: Array.prototype.slice.call(arguments, 2)
-      });
-
-      this._processRemovalQueue();
-
-      return this;
+        // Handle global emit
+        if (this._listeners[event]["*"]) {
+            const arr = this._listeners[event]["*"];
+            const arrCount = arr.length;
+            for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
+                // Check we have a function to execute
+                const tmpFunc = arr[arrIndex];
+                if (typeof tmpFunc === "function") {
+                    return true;
+                }
+            }
+        }
+        return false;
     }
-  }),
-  cancelStatic: new Overload({
     /**
-     * Remove a static event emitter.
-     * @memberof Emitter
-     * @method emitStatic
-     * @param {String} event The event to remove static emitter for.
-     * @returns {*}
+     * Queues an event to be fired. This has automatic de-bouncing so that any
+     * events of the same type that occur within 100 milliseconds of a previous
+     * one will all be wrapped into a single emit rather than emitting tons of
+     * events for the same eventName. Only the data from the last de-bounced event
+     * will be emitted.
+     * @memberOf Emitter
+     * @method deferEmit
+     * @param {String} eventName The name of the event to emit.
+     * @param {*=} data Optional data to emit with the event.
+     * @returns {Emitter} The emitter instance.
      */
-    "string": function string(event) {
-      // Fire global listeners
-      return this.$main(event);
-    },
-
+    deferEmit(eventName, ...data) {
+        if (this._noEmitDefer) {
+            this.emit(eventName, ...data);
+            return this;
+        }
+        // Check for an existing timeout
+        this._deferTimeout = this._deferTimeout || {};
+        if (this._deferTimeout[eventName]) {
+            clearTimeout(this._deferTimeout[eventName]);
+        }
+        // Set a timeout
+        this._deferTimeout[eventName] = setTimeout(() => {
+            this.emit(eventName, ...data);
+        }, 100);
+        return this;
+    }
     /**
-     * Handles removing emitters, is an internal method not called directly.
-     * @param {String} event The event to remove static emitter for.
-     * @returns {*}
+     * If events are cleared with the off() method while the event emitter is
+     * actively processing any events then the off() calls get added to a
+     * queue to be executed after the event emitter is finished. This stops
+     * errors that might occur by potentially modifying the event queue while
+     * the emitter is running through them. This method is called after the
+     * event emitter is finished processing.
      * @private
+     * @returns {undefined}
      */
-    "$main": function $main(event) {
-      this._emitters = this._emitters || {};
-      this._emitters[event] = [];
-      return this;
-    }
-  }),
-
-  /**
-   * Checks if an event has any event listeners or not.
-   * @memberof Emitter
-   * @method willEmit
-   * @param {String} event The name of the event to check for.
-   * @returns {boolean} True if one or more event listeners are registered for
-   * the event. False if none are found.
-   */
-  willEmit: function willEmit(event) {
-    var id = "*";
-
-    if (this._listeners && this._listeners[event]) {
-      var arrIndex, arrCount, tmpFunc, arr; // Handle global emit
-
-      if (this._listeners[event][id]) {
-        arr = this._listeners[event][id];
-        arrCount = arr.length;
-
-        for (arrIndex = 0; arrIndex < arrCount; arrIndex++) {
-          // Check we have a function to execute
-          tmpFunc = arr[arrIndex];
-
-          if (typeof tmpFunc === "function") {
-            return true;
-          }
-        }
-      }
-    }
-
-    return false;
-  },
-
-  /**
-   * Checks if an event has any event listeners or not based on the passed id.
-   * @memberof Emitter
-   * @method willEmitId
-   * @param {String} event The name of the event to check for.
-   * @param {String} id The event ID to check for.
-   * @returns {boolean} True if one or more event listeners are registered for
-   * the event. False if none are found.
-   */
-  willEmitId: function willEmitId(event, id) {
-    if (this._listeners && this._listeners[event]) {
-      var arrIndex, arrCount, tmpFunc, arr; // Handle global emit
-
-      if (this._listeners[event]["*"]) {
-        arr = this._listeners[event]["*"];
-        arrCount = arr.length;
-
-        for (arrIndex = 0; arrIndex < arrCount; arrIndex++) {
-          // Check we have a function to execute
-          tmpFunc = arr[arrIndex];
-
-          if (typeof tmpFunc === "function") {
-            return true;
-          }
+    _processRemovalQueue() {
+        if (!this._eventRemovalQueue || !this._eventRemovalQueue.length) {
+            return;
         }
-      } // Handle id emit
-
-
-      if (this._listeners[event][id]) {
-        arr = this._listeners[event][id];
-        arrCount = arr.length;
-
-        for (arrIndex = 0; arrIndex < arrCount; arrIndex++) {
-          // Check we have a function to execute
-          tmpFunc = arr[arrIndex];
-
-          if (typeof tmpFunc === "function") {
-            return true;
-          }
+        // Execute each removal call
+        for (let i = 0; i < this._eventRemovalQueue.length; i++) {
+            this._eventRemovalQueue[i]();
         }
-      }
+        // Clear the removal queue
+        this._eventRemovalQueue = [];
     }
-
-    return false;
-  },
-
-  /**
-   * If events are cleared with the off() method while the event emitter is
-   * actively processing any events then the off() calls get added to a
-   * queue to be executed after the event emitter is finished. This stops
-   * errors that might occur by potentially modifying the event queue while
-   * the emitter is running through them. This method is called after the
-   * event emitter is finished processing.
-   * @private
-   */
-  _processRemovalQueue: function _processRemovalQueue() {
-    var i;
-
-    if (this._eventRemovalQueue && this._eventRemovalQueue.length) {
-      // Execute each removal call
-      for (i = 0; i < this._eventRemovalQueue.length; i++) {
-        this._eventRemovalQueue[i]();
-      } // Clear the removal queue
-
-
-      this._eventRemovalQueue = [];
+}
+exports.Emitter = Emitter;
+const makeEmitter = (obj, prototypeMode = false) => {
+    let operateOnObject;
+    if (obj === undefined && prototypeMode === undefined) {
+        obj = {};
+        prototypeMode = false;
     }
-  },
-
-  /**
-   * Queues an event to be fired. This has automatic de-bouncing so that any
-   * events of the same type that occur within 100 milliseconds of a previous
-   * one will all be wrapped into a single emit rather than emitting tons of
-   * events for lots of chained inserts etc. Only the data from the last
-   * de-bounced event will be emitted.
-   * @memberof Emitter
-   * @method deferEmit
-   * @param {String} eventName The name of the event to emit.
-   * @param {*=} data Optional data to emit with the event.
-   */
-  deferEmit: function deferEmit(eventName, data) {
-    var self = this,
-        args;
-
-    if (!this._noEmitDefer && (!this._db || this._db && !this._db._noEmitDefer)) {
-      args = arguments; // Check for an existing timeout
-
-      this._deferTimeout = this._deferTimeout || {};
-
-      if (this._deferTimeout[eventName]) {
-        clearTimeout(this._deferTimeout[eventName]);
-      } // Set a timeout
-
-
-      this._deferTimeout[eventName] = setTimeout(function () {
-        self.emit.apply(self, args);
-      }, 1);
-    } else {
-      this.emit.apply(this, arguments);
+    if (typeof obj === "boolean" && prototypeMode === undefined) {
+        prototypeMode = obj;
+        obj = {};
     }
-
-    return this;
-  }
-};
-/**
- * @class Emitter
- * @param {Object=} obj The object / function / class to add event methods to.
- * If none is provided a new object will be created. This allows you to use
- * new Emitter() to generate an event emitter that is not tied to any other
- * object or class.
- * @param {Boolean=} prototypeMode Defaults to true. Set to true to add emitter
- * methods to the the passed object"s prototype property e.g. obj.prototype.on
- * = emitter.on. Set to false to add emitter methods the object directly e.g.
- * obj.on = emitter.on.
- * @constructor
- */
-
-var Emitter = function Emitter(obj, prototypeMode) {
-  var operateOnObject;
-
-  if (obj === undefined && prototypeMode === undefined) {
-    obj = {};
-    prototypeMode = false;
-  }
-
-  if (typeof obj === "boolean" && prototypeMode === undefined) {
-    prototypeMode = obj;
-    obj = {};
-  }
-
-  if (prototypeMode === undefined) {
-    prototypeMode = true;
-  }
-
-  if ((0, _typeof2.default)(obj) !== "object" && typeof obj !== "function") {
-    throw new Error("Cannot operate on a non-object / non-function passed as first argument!");
-  }
-
-  if (prototypeMode) {
-    if (obj.prototype === undefined) {
-      throw new Error("Cannot modify prototype of passed object, it has no prototype property! Was it instantiated with the new operator correctly?");
+    if (prototypeMode === undefined) {
+        prototypeMode = false;
+    }
+    if (typeof obj !== "object" && typeof obj !== "function") {
+        throw new Error("Cannot operate on passed value, it is not an object, function or class!");
+    }
+    if (prototypeMode) {
+        if (obj.prototype === undefined) {
+            throw new Error("Cannot modify prototype of passed object, it has no prototype property!");
+        }
+        operateOnObject = obj.prototype;
+    }
+    else {
+        operateOnObject = obj;
     }
-
-    operateOnObject = obj.prototype;
-  } else {
-    operateOnObject = obj;
-  } // Convert the object prototype to have eventing capability
-
-
-  operateOnObject.on = EventMethods.on;
-  operateOnObject.off = EventMethods.off;
-  operateOnObject.one = EventMethods.one;
-  operateOnObject.once = EventMethods.once;
-  operateOnObject.emit = EventMethods.emit;
-  operateOnObject.emitId = EventMethods.emitId;
-  operateOnObject.emitStatic = EventMethods.emitStatic;
-  operateOnObject.emitStaticId = EventMethods.emitStaticId;
-  operateOnObject.cancelStatic = EventMethods.cancelStatic;
-  operateOnObject.deferEmit = EventMethods.deferEmit;
-  operateOnObject.willEmit = EventMethods.willEmit;
-  operateOnObject.willEmitId = EventMethods.willEmitId;
-  operateOnObject._processRemovalQueue = EventMethods._processRemovalQueue;
-  return obj;
+    // Convert the object to have eventing capability
+    operateOnObject.on = Emitter.prototype.on;
+    operateOnObject.off = Emitter.prototype.off;
+    operateOnObject.one = Emitter.prototype.one;
+    operateOnObject.once = Emitter.prototype.once;
+    operateOnObject.emit = Emitter.prototype.emit;
+    operateOnObject.emitId = Emitter.prototype.emitId;
+    operateOnObject.emitStatic = Emitter.prototype.emitStatic;
+    operateOnObject.emitStaticId = Emitter.prototype.emitStaticId;
+    operateOnObject.cancelStatic = Emitter.prototype.cancelStatic;
+    operateOnObject.deferEmit = Emitter.prototype.deferEmit;
+    operateOnObject.willEmit = Emitter.prototype.willEmit;
+    operateOnObject.willEmitId = Emitter.prototype.willEmitId;
+    operateOnObject._processRemovalQueue = Emitter.prototype._processRemovalQueue;
+    operateOnObject._on = Emitter.prototype._on;
+    operateOnObject._off = Emitter.prototype._off;
+    operateOnObject._once = Emitter.prototype._once;
+    return obj;
 };
-
-Emitter.prototype = EventMethods;
-module.exports = Emitter;
+exports.makeEmitter = makeEmitter;