@creejs/commons-events 1.0.0

package/README.md

@@ -0,0 +1,2 @@
+# commons-events
+An EventEmitter whose API like NodeJS, but more "Common"

package/index.js

@@ -0,0 +1,2 @@
+'use strict'
+module.exports = require('./lib')

package/lib/constants.js

@@ -0,0 +1,6 @@
+'use strict'
+
+const DefaultOwner = 'DOwner$#$'
+module.exports = {
+  DefaultOwner
+}

package/lib/event-emitter.js

@@ -0,0 +1,371 @@
+'use strict'
+// 3rd
+// internal
+const {
+  TypeUtils: { isNil },
+  TypeAssert: {
+    assertString, assertFunction, assertNumber,
+    assertStringOrSymbol, assertNotNil
+  }
+} = require('@creejs/commons-lang')
+
+// owned
+const Event = require('./event')
+// eslint-disable-next-line no-unused-vars
+const Listener = require('./listener')
+
+// module vars
+const MixinMethods = [
+  'on', 'once', 'addListener', 'prependListener', 'prependOnceListener',
+  'off', 'offAll', 'offOwner', 'removeAllListeners', 'removeListener',
+  'emit', 'setMaxListeners', 'getMaxListeners', 'hasOwner',
+  'listeners', 'listenerCount', 'eventNames', 'rawListeners'
+]
+let DefaultMaxListeners = 10
+/**
+ * 1. An EventEmitter follows the API of NodeJS EventEmitter.
+ * 2. Enhancement:
+ *    * Listeners are grouped by "owner".
+ *    * Operation via "owner"
+ *    * Duplicate listeners are filtered out. Only unique One kept.
+ */
+class EventEmitter {
+  /**
+   * Mixes EventEmitter methods into the given object.
+   * @template T
+   * @param {T} obj - The target object to mix methods into.
+   * @returns {T} The modified object with EventEmitter methods.
+   */
+  static mixin (obj) {
+    const emitter = new EventEmitter()
+    // @ts-ignore
+    obj.__emitter = emitter
+    for (const name of MixinMethods) {
+      // @ts-ignore
+      const method = emitter[name]
+      // @ts-ignore
+      obj[name] = method.bind(emitter)
+    }
+    return obj
+  }
+
+  static get defaultMaxListeners () {
+    return DefaultMaxListeners
+  }
+
+  static set defaultMaxListeners (maxListeners) {
+    assertNumber(maxListeners)
+    DefaultMaxListeners = maxListeners ?? 10
+  }
+
+  /**
+   */
+  constructor () {
+    /**
+     * @type {Map<string|Symbol, Event>}
+     */
+    this._name2Event = new Map()
+    this._maxListeners = DefaultMaxListeners
+  }
+
+  /**
+   * Alias of {@linkcode EventEmitter.addListener}
+   * @param {string|Symbol} eventName
+   * @param {function} listener
+   * @param {*} [owner]
+   * @returns {this}
+   */
+  addListener (eventName, listener, owner) {
+    return this.on(eventName, listener, owner)
+  }
+
+  /**
+   * Adds the listener function to the beginning of the listeners array for the event named eventName.
+   * @param {string|Symbol} eventName
+   * @param {function} listener
+   * @param {*} [owner]
+   * @returns {this}
+   */
+  prependListener (eventName, listener, owner) {
+    assertString(eventName)
+    assertFunction(listener)
+    this._checkMaxListeners(eventName)
+
+    const event = this._getOrCreateEvent(eventName)
+    event.prependListener(listener, owner)
+    return this
+  }
+
+  /**
+   * Adds a one-time listener function for the event named eventName to the beginning of the listeners array.
+   * @param {string|Symbol} eventName
+   * @param {function} listener
+   * @param {*} [owner]
+   * @returns {this}
+   */
+  prependOnceListener (eventName, listener, owner) {
+    assertString(eventName)
+    assertFunction(listener)
+    this._checkMaxListeners(eventName)
+
+    const event = this._getOrCreateEvent(eventName)
+    event.prependOnceListener(listener, owner)
+    return this
+  }
+
+  /**
+   * Synchronously calls each of the listeners registered for the event named eventName,
+   * in the order they were registered, passing the supplied arguments to each.
+   * Returns true if the event had listeners, false otherwise.
+   * @param {string|Symbol} eventName - The name of the event.
+   * @param {...*} args arguments to pass to the listeners.
+   * @returns {boolean}
+   */
+  emit (eventName, ...args) {
+    const event = this._name2Event.get(eventName)
+    if (event == null || event.isEmpty()) {
+      return false
+    }
+    event.emit(...args)
+    return true
+  }
+
+  /**
+   * Returns an array listing the events for which the emitter has registered listeners.
+   * @returns {Array<string|Symbol>} An array of event names.
+   */
+  eventNames () {
+    return [...this._name2Event.keys()]
+  }
+
+  getMaxListeners () {
+    return this._maxListeners
+  }
+
+  /**
+   * Returns the number of listeners listening for the event named eventName.
+   * If listener is provided, it will return how many times the listener is found
+   * in the list of the listeners of the event.
+   * @param {string|Symbol} eventName - The name of the event to check
+   * @param {function} [listener] - Optional specific listener to count
+   * @returns {number} The number of listeners for the event
+   */
+  listenerCount (eventName, listener) {
+    assertStringOrSymbol(eventName, 'eventName')
+    const event = this._name2Event.get(eventName)
+    if (event == null || event.isEmpty()) {
+      return 0
+    }
+    return event.listenerCount(listener)
+  }
+
+  /**
+   * Returns a copy of the array of listeners for the event named eventName.
+   * 1. if a callback function added multiple times, it will be returned multiple times.
+   * @param {string} eventName
+   * @returns {Array<function>}
+   */
+  listeners (eventName) {
+    assertStringOrSymbol(eventName, 'eventName')
+    const event = this._name2Event.get(eventName)
+    if (event == null || event.isEmpty()) {
+      return []
+    }
+    return event.callbacks()
+  }
+
+  /**
+   * Removes a callback function from a specific event.
+   * 1. If the event doesn't exist or has no listeners, do nothing
+   * 2. if one callback function added multiple times, all of them will be removed.
+   *    * !!! This is different from the behavior of Node.js EventEmitter.
+   *
+   * @param {string} eventName - The name of the event to remove callback from
+   * @param {function} callback - The callback function to remove
+   * @returns {EventEmitter} Returns the emitter instance for chaining
+   */
+  off (eventName, callback) {
+    const event = this._name2Event.get(eventName)
+    if (event == null) {
+      return this
+    }
+    event.removeListener(callback)
+    if (event.isEmpty()) {
+      this._name2Event.delete(eventName)
+      return this
+    }
+    return this
+  }
+
+  /**
+   * Removes all listeners for the specified event.
+   * if owner is limited, only the listeners of the owner will be removed.
+   *
+   * @param {string|Symbol} eventName - The name of the event to clear listeners for.
+   * @param {*} owner - The owner whose listeners should be removed.
+   * @returns {EventEmitter} The emitter instance for chaining.
+   */
+  offAll (eventName, owner) {
+    assertStringOrSymbol(eventName, 'eventName')
+    const event = this._name2Event.get(eventName)
+    if (event == null) {
+      return this
+    }
+    event.removeAllListeners(owner)
+    if (event.isEmpty()) {
+      this._name2Event.delete(eventName)
+      return this
+    }
+    return this
+  }
+
+  /**
+   * Removes all event listeners belonging to the specified owner.
+   * @param {*} owner - The owner whose listeners should be removed.
+   * @returns {this}
+   */
+  offOwner (owner) {
+    assertNotNil(owner, 'owner')
+    const events = [...this._name2Event.values()]
+    for (const event of events) {
+      event.removeAllListeners(owner)
+      if (event.isEmpty()) {
+        this._name2Event.delete(event.name)
+      }
+    }
+    return this
+  }
+
+  /**
+   * Adds the listener function to the end of the listeners array for the event named eventName.
+   * @param {string|Symbol} eventName
+   * @param {function} callback
+   * @param {*} [owner]
+   * @returns {this}
+   */
+  on (eventName, callback, owner) {
+    assertString(eventName)
+    assertFunction(callback)
+    this._checkMaxListeners(eventName)
+
+    const event = this._getOrCreateEvent(eventName)
+    event.addListener(callback, owner)
+    return this
+  }
+
+  /**
+   * Checks if the number of listeners for the given event exceeds the maximum allowed.
+   * Emits a warning if the listener count reaches or exceeds the maxListeners threshold.
+   * @private
+   * @param {string|Symbol} eventName - The name of the event to check
+   * @returns {void}
+   */
+  _checkMaxListeners (eventName) {
+    let listenerCount = 0
+    if (this._maxListeners !== 0 && this._maxListeners !== Infinity && (listenerCount = this.listenerCount(eventName)) >= this._maxListeners) {
+      console.warn(`maxlistenersexceededwarning: Possible EventEmitter memory leak detected. ${listenerCount} ${eventName} listeners added to [${this}]. Use emitter.setMaxListeners() to increase limit`)
+    }
+  }
+
+  /**
+   * Adds a listener that will be invoked only once for the event named eventName.SIGINT listeners added to [process]. Use emitter.setMaxListeners() to increase limit`)
+    }
+  }
+
+  /**
+   * Adds a one-time callback function for the specified event.
+   * The callback is invoked only once and then automatically removed.
+   *
+   * @param {string} eventName - The name of the event to listen for.
+   * @param {Function} callback - The callback function to execute when the event is emitted.
+   * @param {*} [owner] - Optional owner used to group listener callbacks.
+   * @returns {EventEmitter} Returns the emitter instance for chaining.
+   */
+  once (eventName, callback, owner) {
+    assertString(eventName)
+    assertFunction(callback)
+
+    const event = this._getOrCreateEvent(eventName)
+    event.addOnceListener(callback, owner)
+    return this
+  }
+
+  /**
+   * Returns a copy of the array of listeners for the event named eventName,
+   * including any wrappers (such as those created by .once()).
+   * @param {string} eventName - The name of the event.
+   * @returns {Listener[]} An array of raw listener functions, or empty array if none exist.
+   */
+  rawListeners (eventName) {
+    return this._name2Event.get(eventName)?.rawListeners() || []
+  }
+
+  /**
+   * Alias of {@linkcode EventEmitter.offAll}
+   * @param {string|Symbol} eventName - The name of the event to remove listeners for.
+   * @param {*} owner - The owner of the listeners to be removed.
+   * @returns {EventEmitter} The emitter instance for chaining.
+   */
+  removeAllListeners (eventName, owner) {
+    return this.offAll(eventName, owner)
+  }
+
+  /**
+   * Alias of {@linkcode EventEmitter.off}
+   * @param {string} eventName - The name of the event.
+   * @param {Function} callback - The callback function to remove.
+   * @returns {EventEmitter} The emitter instance for chaining.
+   */
+  removeListener (eventName, callback) {
+    return this.off(eventName, callback)
+  }
+
+  /**
+   * Sets the maximum number of listeners that can be added to this event emitter.
+   * @param {number} max - The maximum number of listeners.
+   * @returns {this} The set maximum number of listeners.
+   */
+  setMaxListeners (max) {
+    assertNumber(max)
+    if (max < 0) {
+      throw new RangeError('maxListeners must >=0')
+    }
+    this._maxListeners = max
+    return this
+  }
+
+  /**
+   * Gets an existing event by name or creates a new one if it doesn't exist.
+   * @private
+   * @param {string|Symbol} eventName - The name of the event to get or create.
+   * @returns {Event} The existing or newly created Event instance.
+   */
+  _getOrCreateEvent (eventName) {
+    if (this._name2Event.has(eventName)) {
+      // @ts-ignore
+      return this._name2Event.get(eventName)
+    }
+    const event = new Event(eventName)
+    this._name2Event.set(eventName, event)
+    return event
+  }
+
+  /**
+   * Checks if the specified owner has any registered events.
+   * @param {Object} owner - The owner object to check for registered events.
+   * @returns {boolean} True if the owner has any registered events, false otherwise.
+   */
+  hasOwner (owner) {
+    if (isNil(owner)) {
+      return false
+    }
+    for (const event of this._name2Event.values()) {
+      if (event.hasOwner(owner)) {
+        return true
+      }
+    }
+    return false
+  }
+}
+
+module.exports = EventEmitter

package/lib/event.js

@@ -0,0 +1,358 @@
+'use strict'
+// 3rd
+// internal
+const { TypeUtils: { isFunction, isNil }, TypeAssert: { assertStringOrSymbol } } = require('@creejs/commons-lang')
+// eslint-disable-next-line no-unused-vars
+const Listener = require('./listener')
+const { DefaultOwner } = require('./constants')
+
+// module vars
+
+/**
+ * An Event definition
+ * 1. listeners are grouped by owner
+ *    * if not specified, group it into one Default owner
+ * 2. one listener may belong to multiple owners
+ * 3. one owner may have multiple listeners
+ */
+class Event {
+  static get DefaultOwner () {
+    return DefaultOwner
+  }
+
+  /**
+   * Creates a new Event instance with the specified name.
+   * @param {string|Symbol} eventName - The name of the event.
+   */
+  constructor (eventName) {
+    assertStringOrSymbol(eventName, 'eventName')
+    this._name = eventName
+    /**
+     * use Set to store unique listeners
+     * @type {Set<function>}
+     */
+    this._callbacks = new Set()
+    /**
+     * @type {Array<Listener>}
+     */
+    this._listeners = [] // user array to keep order
+    /**
+     * @type {Map<function, Set<Listener>>}
+     */
+    this._callback2Listeners = new Map()
+    /**
+     * use listener to index owners. One Listener Instance only belongs to one owner
+     * @type {Map<Listener, *>}
+    */
+    this._listener2Owner = new Map()
+    /**
+     * use "owner" to group listeners; one owner may have multiple listeners
+     * @type {Map<*, Set<Listener>>}
+     */
+    this._owner2Listeners = new Map()
+  }
+
+  /**
+   * Name of the event.
+   * @returns {string|Symbol}
+   */
+  get name () {
+    return this._name
+  }
+
+  isEmpty () {
+    return this._callbacks.size === 0
+  }
+
+  /**
+   * Returns a copy of the raw listeners array.
+   * @returns {Array<Listener>} A shallow copy of the listeners array.
+   */
+  rawListeners () {
+    return [...this._listeners]
+  }
+
+  /**
+   * Returns the number of listeners listening for the event.
+   * If callback is provided, it will return how many times the callback is found in the list of the listeners
+   * @param {Function} [callback] - The callback function to count
+   * @returns {number}
+   */
+  listenerCount (callback) {
+    if (callback == null) {
+      return this._listeners.length
+    }
+    return this._callback2Listeners.get(callback)?.size ?? 0
+  }
+
+  /**
+   * Returns a shallow copy of the registered callbacks array.
+   * if one callback function is added multiple times, it will be returned multiple times.
+   * @returns {Array<function>} A new array containing all registered callbacks.
+   */
+  callbacks () {
+    return [...this.rawListeners().map(listener => listener.callback)]
+  }
+
+  /**
+   * Emits current event, invoking all registered listeners by order.
+   * @param {...*} args - Arguments to be passed to each listener.
+   * @returns {boolean} True if the event had listeners, false otherwise.
+   */
+  emit (...args) {
+    if (this._listeners.length === 0) {
+      return false
+    }
+    // Clone _listeners, it may be changed during call listener
+    for (const listener of [...this._listeners]) {
+      listener.invoke(...args)
+    }
+    return true
+  }
+
+  /**
+   * Checks if listener is registered with this event.
+   * @param {function} callback - The listener function to check.
+   * @returns {boolean} True if the listener is registered, false otherwise.
+   */
+  hasListener (callback) {
+    if (!isFunction(callback)) {
+      return false
+    }
+    return this._callbacks.has(callback)
+  }
+
+  /**
+   * Checks if owner has any registered listeners.
+   * @param {*} owner - The owner to check for registered listeners.
+   * @returns {boolean} True if the owner has listeners, false otherwise.
+   */
+  hasOwner (owner) {
+    if (isNil(owner)) {
+      return false
+    }
+    return this._owner2Listeners.has(owner)
+  }
+
+  /**
+   * Adds an event listener
+   * @param {function} callback - The callback function to be invoked when the event occurs.
+   * @param {*} [owner] - use "owner" to group listeners, then can remove all listeners for an owner.
+   * @returns {boolean} true if added, false otherwise.
+   */
+  addListener (callback, owner) {
+    return this._addListener(callback, owner, false, false)
+  }
+
+  /**
+   * Prepends a listener callback to the beginning of the listeners array.
+   * No checks are made to see if the listener has already been added.
+   * Multiple calls passing the same combination of eventName and listener will result in the listener being added,
+   * and called, multiple times.
+   * @param {Function} callback - The callback function to be executed when the event is emitted.
+   * @param {Object} owner - The owner object to which the listener belongs.
+   * @returns {boolean}
+   */
+  prependListener (callback, owner) {
+    return this._addListener(callback, owner, false, true)
+  }
+
+  /**
+   * Adds a one-time listener for the event. The listener is automatically removed after being invoked once.
+   * @param {Function} callback - The function to call when the event is triggered.
+   * @param {Object} [owner] - The object that owns the callback (used for binding `this` context).
+   * @returns {boolean}
+   */
+  addOnceListener (callback, owner) {
+    return this._addListener(callback, owner, true, false)
+  }
+
+  /**
+   * Adds a one-time event listener that will be automatically removed after being triggered once.
+   * The listener will only be triggered if the event is pretended (simulated).
+   * @param {Function} callback - The function to call when the event is triggered.
+   * @param {Object} owner - The object that owns the listener (used for reference tracking).
+   * @returns {boolean} The listener function that was added.
+   */
+  prependOnceListener (callback, owner) {
+    return this._addListener(callback, owner, true, true)
+  }
+
+  /**
+   * Adds a listener for the event.
+   * @param {Function} callback - The callback function to be executed when the event occurs
+   * @param {*} [owner] - The owner object that the listener belongs to (defaults to DeaultOwner)
+   * @param {boolean} [isOnce=false] - Whether the listener should be removed after first invocation
+   * @param {boolean} [isPrepend=false] - Whether the listener should be inert at the beginning of the listeners array
+   * @returns {boolean} Returns true if listener was added successfully, false if callback is nil or duplicate
+   * @protected
+   */
+  _addListener (callback, owner, isOnce, isPrepend) {
+    if (isNil(callback)) {
+      return false
+    }
+    if (!this._callbacks.has(callback)) {
+      this._callbacks.add(callback)
+    }
+    // a listener must belong to an owner
+    owner = owner ?? DefaultOwner
+
+    // use Listener to wrap callback
+    const listener = new Listener(this, callback, isOnce)
+    listener.owner = owner
+    if (isPrepend) {
+      this._listeners.unshift(listener)
+    } else {
+      this._listeners.push(listener)
+    }
+
+    // index, rapadly find one listener's owner
+    this._listener2Owner.set(listener, owner)
+
+    // one callback function may be registered many times
+    let callbackListeners = this._callback2Listeners.get(callback)
+    if (callbackListeners == null) {
+      callbackListeners = new Set()
+      this._callback2Listeners.set(callback, callbackListeners)
+    }
+    callbackListeners.add(listener)
+
+    // group by owner
+    let ownerListeners = this._owner2Listeners.get(owner)
+    if (ownerListeners == null) {
+      ownerListeners = new Set()
+      this._owner2Listeners.set(owner, ownerListeners)
+    }
+    ownerListeners.add(listener)
+
+    return true
+  }
+
+  /**
+   * Removes a callback
+   * @param {Function} callback - The callback function to remove.
+   * @returns {boolean} true if removed, false otherwise.
+   */
+  removeListener (callback) {
+    if (isNil(callback)) {
+      return false
+    }
+    if (!this._callbacks.has(callback)) {
+      return false
+    }
+    this._callbacks.delete(callback)
+
+    const listeners = this._callback2Listeners.get(callback)
+    if (listeners == null) { // should not happen
+      return false
+    }
+    this._callback2Listeners.delete(callback)
+    for (const listener of listeners) {
+      // remove from global index
+      const index = this._listeners.indexOf(listener)
+      index !== -1 && this._listeners.splice(this._listeners.indexOf(listener), 1)
+
+      // remove from owner index
+      const owner = this._listener2Owner.get(listener)
+      if (owner == null) {
+        continue
+      }
+      this._listener2Owner.delete(listener)
+      const ownerListeners = this._owner2Listeners.get(owner)
+      if (ownerListeners == null) {
+        continue
+      }
+      ownerListeners.delete(listener)
+      if (ownerListeners.size === 0) {
+        this._owner2Listeners.delete(owner)
+      }
+    }
+    return true
+  }
+
+  /**
+   * Removes a listener from both global and owner indexes.
+   * @param {Listener} listener - The listener function to remove
+   */
+  _remove (listener) {
+    // remove from global index
+    const index = this._listeners.indexOf(listener)
+    index !== -1 && this._listeners.splice(index, 1)
+
+    // clean callback index
+    const { callback } = listener
+    const callbackListeners = this._callback2Listeners.get(callback)
+    if (callbackListeners != null) {
+      callbackListeners.delete(listener)
+      if (callbackListeners.size === 0) {
+        this._callback2Listeners.delete(callback)
+        this._callbacks.delete(callback)
+      }
+    }
+
+    // remove from owner index
+    const owner = this._listener2Owner.get(listener)
+    if (owner == null) {
+      return
+    }
+    this._listener2Owner.delete(listener)
+    const ownerListeners = this._owner2Listeners.get(owner)
+    if (ownerListeners == null) {
+      return
+    }
+    ownerListeners.delete(listener)
+    if (ownerListeners.size === 0) {
+      this._owner2Listeners.delete(owner)
+    }
+  }
+
+  /**
+   * Removes all event listeners
+   * @param {*} [owner] - Without owner, all listeners will be removed; otherwise, only listeners of "owner" will be removed.
+   * @returns {this}
+   */
+  removeAllListeners (owner) {
+    // remove listeners of owner
+    if (isNil(owner)) {
+      // remove all Listeners
+      this._callbacks.clear()
+      this._listeners.length = 0
+      this._callback2Listeners.clear()
+      this._listener2Owner.clear()
+      this._owner2Listeners.clear()
+      return this
+    }
+    // all listeners of the owner
+    const ownerListeners = this._owner2Listeners.get(owner)
+    // no owner
+    if (ownerListeners == null) {
+      return this
+    }
+    // clear owner index
+    this._owner2Listeners.delete(owner)
+    // clearn listeners of owner one by one
+    for (const listener of ownerListeners) {
+      // remove from global index
+      const index = this._listeners.indexOf(listener)
+      index !== -1 && this._listeners.splice(this._listeners.indexOf(listener), 1)
+
+      // clean listener-owner index
+      this._listener2Owner.delete(listener)
+
+      // one callback function may be registered many times, has many Listeners
+      const { callback } = listener
+      const callbackListeners = this._callback2Listeners.get(callback)
+      if (callbackListeners == null) {
+        continue
+      }
+      callbackListeners.delete(listener)
+      if (callbackListeners.size === 0) {
+        this._callback2Listeners.delete(callback)
+        this._callbacks.delete(callback)
+      }
+    }
+    return this
+  }
+}
+
+module.exports = Event

package/lib/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const EventEmitter = require('./event-emitter')
+
+module.exports = {
+  EventEmitter
+}

package/lib/listener.js

@@ -0,0 +1,93 @@
+'use strict'
+// 3rd
+// internal
+const { TypeAssert: { assertFunction, assertNotNil } } = require('@creejs/commons-lang')
+
+// owned
+const { DefaultOwner } = require('./constants')
+// eslint-disable-next-line no-unused-vars
+const Event = require('./event')
+/**
+ * Wraps a function to be called when an event is fired.
+ * @class Listener
+ */
+class Listener {
+  /**
+   * @param {Event} event
+   * @param {function} callback - The function to be called when event is fired
+   * @param {boolean} [isOnce=false] - is a one time listener?
+   */
+  constructor (event, callback, isOnce = false) {
+    assertNotNil(event, 'event')
+    assertFunction(callback, 'callback')
+    this._event = event
+    this._callback = callback
+    this._isOnce = !!isOnce // is Once Listener?
+    this._owner = undefined
+  }
+
+  /**
+   * Sets the owner of this listener.
+   * @param {*} owner - The owner object to be associated with this listener.
+   */
+  set owner (owner) {
+    this._owner = owner
+  }
+
+  get owner () {
+    return this._owner === DefaultOwner ? undefined : this._owner
+  }
+
+  get event () {
+    return this._event
+  }
+
+  get isOnce () {
+    return this._isOnce
+  }
+
+  /**
+   * Checks if the provided function is the same as the listener's wrapped function.
+   * @param {Function} callback - The function to compare against.
+   * @returns {boolean} True if the functions are the same, false otherwise.
+   */
+  isSameCallback (callback) {
+    return this._callback === callback
+  }
+
+  get callback () {
+    return this._callback
+  }
+
+  /**
+   * Invokes the stored function with the provided arguments.
+   * @param {...*} args - Arguments to pass to the function.
+   * @returns {*} The result of the function invocation.
+   */
+  invoke (...args) {
+    try {
+      return this._callback(...args)
+    } finally {
+      if (this._isOnce) {
+        try {
+          this._event._remove(this)
+        } catch (err) {
+          // do nothing
+          console.warn(err)
+        }
+      }
+    }
+  }
+
+  /**
+   * Invokes the listener with the provided arguments.
+   * Alias for {@linkcode Listener.invoke}
+   * @param {...*} args - Arguments to be passed to the listener.
+   * @returns {*} The result of the listener invocation.
+   */
+  listener (...args) {
+    return this.invoke(...args)
+  }
+}
+
+module.exports = Listener

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@creejs/commons-events",
+  "version": "1.0.0",
+  "description": "Commons EventEmitter",
+  "main": "index.js",
+  "private": false,
+  "files": [
+    "index.js",
+    "lib/",
+    "types/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/frameworkee/commons.git"
+  },
+  "scripts": {
+    "dts": "tsc",
+    "generate-docs": "node_modules/.bin/jsdoc -c ./jsdoc.json"
+  },
+  "author": "rodney.vin@gmail.com",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@creejs/commons-lang": "^1.0.0"
+  },
+  "devDependencies": {
+    "better-docs": "^2.7.3",
+    "jsdoc": "^4.0.4"
+  }
+}