events-ex 2.1.1 → 2.3.0

package/lib/default-methods.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 exports.getEventableMethods = getEventableMethods;
 var _utilEx = require("util-ex");
+require("./util/promise-any");
 var _consts = require("./consts");
 var _event = require("./event");
 const create = Object.create;
@@ -17,11 +18,61 @@ function isRegExp(value) {
 }
 function getEventableMethods(aClass) {
   return {
+    /**
+     * Configures the event emitter with specified options using a Fluent API.
+     * @param {Object} options - Configuration options for event emission.
+     * @param {string} [options.asyncMode='serial'] - The mode of asynchronous emission ('serial' or 'parallel').
+     * @param {string} [options.resultMode='last'] - The strategy for handling multiple return values ('last', 'first', 'collect').
+     * @returns {import('./event-emitter').EventEmitter} A proxy object representing the configured EventEmitter.
+     */
+    configure(options) {
+      const proxy = Object.create(this);
+      const mergedOptions = Object.assign({}, this._eeRuntimeOptions, options);
+      (0, _utilEx.defineProperty)(proxy, '_eeRuntimeOptions', mergedOptions);
+      return proxy;
+    },
+    /**
+     * A shortcut for parallel configuration.
+     * @param {string} [resultMode='last'] - The strategy for handling multiple return values.
+     * @returns {import('./event-emitter').EventEmitter} A proxy object representing the configured EventEmitter.
+     */
+    parallel(resultMode) {
+      return this.configure({
+        asyncMode: 'parallel',
+        resultMode: resultMode || 'last'
+      });
+    },
+    /**
+     * Sets the configuration options for the EventEmitter instance.
+     * @param {Object} options - Configuration options for the emitter (e.g., asyncMode, resultMode, maxListeners).
+     * @returns {import('./event-emitter').EventEmitter} The EventEmitter instance for chaining.
+     */
+    setEmitterOptions(options) {
+      if (!(0, _utilEx.isObject)(options)) {
+        return this;
+      }
+      let data;
+      if (!this.hasOwnProperty('_emitterOptions')) {
+        data = create(null);
+        (0, _utilEx.defineProperty)(this, '_emitterOptions', data);
+      } else {
+        data = this._emitterOptions;
+      }
+      Object.assign(data, options);
+      if (!(0, _utilEx.isUndefined)(options.maxListeners) && (0, _utilEx.isFunction)(this.setMaxListeners)) {
+        this.setMaxListeners(options.maxListeners);
+      }
+      return this;
+    },
     /**
      * Adds a listener function to the specified event type.
      * @param {string|RegExp} type - The event type to listen for.
      * @param {Function} listener - The listener function to be called when the event is emitted.
-     * @param {number} [index] - The index at which to insert the listener. If not specified, the listener will be added at the end of the listeners array.
+     * @param {number|'first'|'last'} [index] - The index at which to insert the listener. 
+     *        - 'first' or -Infinity: Adds to the "Head" zone. The first listener added as 'first' is placed at the very front.
+     *        - 'last' or Infinity: Adds to the "Tail" zone. The first listener added as 'last' will always be the very last one to execute.
+     *        - number: Inserts at the specified index within the "Body" (normal) zone.
+     *        If not specified, the listener is added to the end of the "Body" zone.
      * @returns {import('./event-emitter').EventEmitter} The EventEmitter instance to allow chaining.
      * @throws {TypeError} If the listener is not a function.
      */
@@ -44,16 +95,35 @@ function getEventableMethods(aClass) {
       if (isRegExp(type)) {
         data = data[_consts.RegExpEventSymbol] || (data[_consts.RegExpEventSymbol] = create(null));
       }
+      const isFirst = index === 'first' || index === -Infinity;
+      const isLast = index === 'last' || index === Infinity;
       if (!data[type]) {
-        data[type] = listener;
-      } else if ((0, _utilEx.isObject)(data[type])) {
-        if (typeof index === 'number') {
-          data[type].splice(index, 0, listener);
+        if (isFirst || isLast || typeof index === 'number') {
+          data[type] = [listener];
+          if (isFirst) data[type]._headCount = 1;
+          if (isLast) data[type]._tailCount = 1;
         } else {
-          data[type].push(listener);
+          data[type] = listener;
         }
       } else {
-        data[type] = [data[type], listener];
+        if ((0, _utilEx.isFunction)(data[type])) {
+          data[type] = [data[type]];
+        }
+        const listeners = data[type];
+        const headCount = listeners._headCount || 0;
+        const tailCount = listeners._tailCount || 0;
+        if (isFirst) {
+          listeners.splice(headCount, 0, listener);
+          listeners._headCount = headCount + 1;
+        } else if (isLast) {
+          listeners.splice(listeners.length - tailCount, 0, listener);
+          listeners._tailCount = tailCount + 1;
+        } else if (typeof index === 'number' && !isNaN(index)) {
+          const pos = Math.min(Math.max(headCount + index, headCount), listeners.length - tailCount);
+          listeners.splice(pos, 0, listener);
+        } else {
+          listeners.splice(listeners.length - tailCount, 0, listener);
+        }
       }
       // Check for listener leak
       if ((0, _utilEx.isObject)(data[type]) && !data[type].warned) {
@@ -74,7 +144,11 @@ function getEventableMethods(aClass) {
      * Adds a one-time listener function to the specified event type.
      * @param {string|RegExp} type - The event type to listen for.
      * @param {Function} listener - The listener function to be called once when the event is emitted.
-     * @param {number} [index] - The index at which to insert the listener. If not specified, the listener will be added at the end of the listeners array.
+     * @param {number|'first'|'last'} [index] - The index at which to insert the listener.
+     *        - 'first' or -Infinity: Adds to the "Head" zone. The first listener added as 'first' is placed at the very front.
+     *        - 'last' or Infinity: Adds to the "Tail" zone. The first listener added as 'last' will always be the very last one to execute.
+     *        - number: Inserts at the specified index within the "Body" (normal) zone.
+     *        If not specified, the listener is added to the end of the "Body" zone.
      * @returns {import('./event-emitter').EventEmitter} The EventEmitter instance to allow chaining.
      * @throws {TypeError} If the listener is not a function.
      */
@@ -100,7 +174,7 @@ function getEventableMethods(aClass) {
      * @param {...*} args - The event type followed by any number of arguments to be passed to the listener functions.
      * @returns {*} The result of the event.
      */
-    emit( /* type, msg , ... */
+    emit(/* type, msg , ... */
     ) {
       const r = _emit.apply(this, arguments);
       if (!r) {
@@ -143,7 +217,7 @@ function getEventableMethods(aClass) {
      * @param {...*} args - The event type followed by any number of arguments to be passed to the listener functions.
      * @returns {Promise<*>} A promise that resolves with the result of the event.
      */
-    async emitAsync( /* type, msg , ... */
+    async emitAsync(/* type, msg , ... */
     ) {
       const r = _emit.apply(this, arguments);
       if (!r) {
@@ -152,27 +226,9 @@ function getEventableMethods(aClass) {
       const args = r.args;
       const listeners = r.listeners;
       const evt = (0, _event.Event)(this, r.type);
-      const errs = [];
+      const options = Object.assign({}, this._emitterOptions, this._eeRuntimeOptions);
       try {
-        for (const listener of listeners) {
-          try {
-            await _notify(listener, evt, args);
-            if (evt.stopped) {
-              break;
-            }
-          } catch (err) {
-            errs.push({
-              err: err,
-              listener: listener
-            });
-          }
-        }
-        if (errs.length) {
-          for (let i = 0; i < errs.length; i++) {
-            const it = errs[i];
-            this.emit('error', it.err, 'notify', r.type, it.listener, args);
-          }
-        }
+        await _executeAsync.call(this, listeners, evt, args, options);
       } finally {
         // eslint-disable-next-line no-unsafe-finally
         return evt.end();
@@ -266,10 +322,14 @@ function getEventableMethods(aClass) {
         if (i < 0) {
           return this;
         }
+        if (listeners._headCount && i < listeners._headCount) {
+          listeners._headCount--;
+        } else if (listeners._tailCount && i >= listeners.length - listeners._tailCount) {
+          listeners._tailCount--;
+        }
         if (listeners.length === 1) {
-          listeners.length = 0;
           delete data[type];
-        } else if (listeners.length === 2) {
+        } else if (listeners.length === 2 && !listeners._headCount && !listeners._tailCount) {
           data[type] = listeners[i ? 0 : 1];
           listeners.length = 1;
         } else {
@@ -420,4 +480,67 @@ function _notify(listener, evt, args) {
       }
   }
   return result;
+}
+async function _executeAsync(listeners, evt, args, options) {
+  const asyncMode = options.asyncMode || 'serial';
+  const resultMode = options.resultMode || 'last';
+  const errs = [];
+  if (resultMode === 'collect') {
+    evt.result = [];
+  }
+  const notifyListener = async listener => {
+    try {
+      const result = await _notify(listener, evt, args);
+      if (result !== undefined) {
+        if (resultMode === 'first' && !evt.resolved) {
+          evt.result = result;
+          evt.resolved = true;
+        } else if (resultMode === 'last') {
+          evt.result = result;
+        }
+      }
+      return result;
+    } catch (err) {
+      errs.push({
+        err,
+        listener
+      });
+      throw err;
+    }
+  };
+  if (asyncMode === 'parallel') {
+    const promises = listeners.map(listener => notifyListener(listener));
+    if (resultMode === 'collect') {
+      evt.result = await Promise.all(promises.map(p => p.catch(() => undefined)));
+    } else if (resultMode === 'first') {
+      try {
+        await Promise.any(promises.map(p => p.then(res => res === undefined ? Promise.reject() : res)));
+      } catch (e) {
+        // If all rejected or returned undefined, ignore
+      }
+    } else {
+      await Promise.all(promises.map(p => p.catch(() => undefined)));
+    }
+  } else {
+    // Serial mode (default)
+    for (const listener of listeners) {
+      try {
+        const result = await notifyListener(listener);
+        if (resultMode === 'collect') {
+          evt.result.push(result);
+        }
+        if (evt.stopped || resultMode === 'first' && evt.resolved) break;
+      } catch (err) {
+        if (resultMode === 'collect') {
+          evt.result.push(undefined);
+        }
+      }
+    }
+  }
+  if (errs.length) {
+    for (let i = 0; i < errs.length; i++) {
+      const it = errs[i];
+      this.emit('error', it.err, 'notify', evt.type, it.listener, args);
+    }
+  }
 }

package/lib/event-emitter.d.ts

@@ -10,18 +10,28 @@ export class EventEmitter {
    * Adds a listener function to the specified event type.
    * @param {string|RegExp} type - The event type to listen for.
    * @param {Function} listener - The listener function to be called when the event is emitted.
+   * @param {number|'first'|'last'} [index] - The index at which to insert the listener.
+   *        - 'first' or -Infinity: adds to the beginning of the listeners (stay at the front).
+   *        - 'last' or Infinity: adds to the end of the listeners (stay at the back).
+   *        - number: inserts at the specified index within the normal listeners zone.
+   *        If not specified, the listener will be added at the end of the normal listeners.
    * @returns {EventEmitter} The EventEmitter instance to allow chaining.
    * @throws {TypeError} If the listener is not a function.
    */
-  on(eventName: string|RegExp, listener: ListenerCallbackFunc): EventEmitter;
+  on(eventName: string|RegExp, listener: ListenerCallbackFunc, index?: number|'first'|'last'): EventEmitter;
   /**
    * Adds a one-time listener function to the specified event type.
    * @param {string|RegExp} type - The event type to listen for.
    * @param {Function} listener - The listener function to be called once when the event is emitted.
+   * @param {number|'first'|'last'} [index] - The index at which to insert the listener.
+   *        - 'first' or -Infinity: adds to the beginning of the listeners (stay at the front).
+   *        - 'last' or Infinity: adds to the end of the listeners (stay at the back).
+   *        - number: inserts at the specified index within the normal listeners zone.
+   *        If not specified, the listener will be added at the end of the normal listeners.
    * @returns {EventEmitter} The EventEmitter instance to allow chaining.
    * @throws {TypeError} If the listener is not a function.
    */
-  once(eventName: string|RegExp, listener: ListenerCallbackFunc): EventEmitter;
+  once(eventName: string|RegExp, listener: ListenerCallbackFunc, index?: number|'first'|'last'): EventEmitter;
   /**
    * Removes a listener function from the specified event type.
    * @param {string|RegExp} type - The event type to remove the listener from.

package/lib/event.d.ts

@@ -5,7 +5,7 @@
  * @param {import('./event-emitter').EventEmitter} target - Who trigger the event
  * @returns {Event} - The new Event instance.
  */
-export function Event(target: import('./event-emitter').EventEmitter, type: any): Event;
+export function Event(target: import("./event-emitter").EventEmitter, type: any): Event;
 export class Event {
     /**
      * Creates a new Event object instance that contains information about the event, such as the target element and the return value of the event.
@@ -14,12 +14,12 @@ export class Event {
      * @param {import('./event-emitter').EventEmitter} target - Who trigger the event
      * @returns {Event} - The new Event instance.
      */
-    constructor(target: import('./event-emitter').EventEmitter, type: any);
+    constructor(target: import("./event-emitter").EventEmitter, type: any);
     /**
      * Initializes the event with the target object.
      * @param {import('./event-emitter').EventEmitter} target - The target object for the event.
      */
-    init(target: import('./event-emitter').EventEmitter, type: any): void;
+    init(target: import("./event-emitter").EventEmitter, type: any): void;
     /**
      * Who trigger the event
      * @type {Object}
@@ -32,6 +32,12 @@ export class Event {
      * @public
      */
     public stopped: boolean;
+    /**
+     * Whether a result has been resolved (for 'first' result mode)
+     * @type {boolean}
+     * @public
+     */
+    public resolved: boolean;
     /**
      * Keep your event result here if any.
      * @type {*}

package/lib/event.js

@@ -37,6 +37,12 @@ Event.prototype.init = function (target, type) {
    * @public
    */
   this.stopped = false;
+  /**
+   * Whether a result has been resolved (for 'first' result mode)
+   * @type {boolean}
+   * @public
+   */
+  this.resolved = false;
   /**
    * Keep your event result here if any.
    * @type {*}

package/lib/eventable.js

@@ -7,7 +7,7 @@ exports.eventable = exports.default = void 0;
 var _customAbility = require("custom-ability");
 var _defineProperty = _interopRequireDefault(require("util-ex/lib/defineProperty"));
 var _defaultMethods = _interopRequireDefault(require("./default-methods"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**
  * Creates an Eventable class with event-emitting capabilities.
  *
@@ -31,6 +31,9 @@ function getEventableClass(aClass) {
   Eventable.prototype.listenerCount = methods.listenerCount;
   Eventable.prototype.emit = methods.emit;
   Eventable.prototype.emitAsync = methods.emitAsync;
+  Eventable.prototype.configure = methods.configure;
+  Eventable.prototype.parallel = methods.parallel;
+  Eventable.prototype.setEmitterOptions = methods.setEmitterOptions;
   Eventable.prototype.on = methods.on;
   Eventable.prototype.addListener = methods.on;
   Eventable.prototype.off = methods.off;

package/lib/pipe-async.d.ts

@@ -4,8 +4,11 @@
  * @param {import('./event-emitter').EventEmitter} e1 - The first event emitter.
  * @param {import('./event-emitter').EventEmitter} e2 - The second event emitter.
  * @param {string} [name='emitAsync'] - The name of the event to pipe (defaults to 'emitAsync').
+ * @param {Object} [options] - Configuration for the pipeline.
+ * @param {string} [options.asyncMode='serial'] - The mode of propagation ('serial' or 'parallel').
+ * @param {string} [options.resultMode] - Strategy for aggregating results from the pipe chain ('collect', 'first').
  * @returns {Object} - An object with a `close` method that removes the pipeline between the two event emitters.
  * @throws {TypeError} - If either of the arguments is not an event emitter object.
  */
-export function pipeAsync(e1: import('./event-emitter').EventEmitter, e2: import('./event-emitter').EventEmitter, ...args: any[]): any;
+export function pipeAsync(e1: import("./event-emitter").EventEmitter, e2: import("./event-emitter").EventEmitter, ...args: any[]): any;
 export default pipeAsync;

package/lib/pipe-async.js

@@ -9,7 +9,7 @@ var _defineProperty = _interopRequireDefault(require("util-ex/lib/defineProperty
 var _wrapEventEmitter = require("./wrap-event-emitter");
 var _arrayRemove = _interopRequireDefault(require("./util/array-remove"));
 var _validObject = _interopRequireDefault(require("./util/valid-object"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
 const arrFrom = Array.from;
@@ -21,16 +21,27 @@ const emit = _wrapEventEmitter.methods.emitAsync;
  * @param {import('./event-emitter').EventEmitter} e1 - The first event emitter.
  * @param {import('./event-emitter').EventEmitter} e2 - The second event emitter.
  * @param {string} [name='emitAsync'] - The name of the event to pipe (defaults to 'emitAsync').
+ * @param {Object} [options] - Configuration for the pipeline.
+ * @param {string} [options.asyncMode='serial'] - The mode of propagation ('serial' or 'parallel').
+ * @param {string} [options.resultMode] - Strategy for aggregating results from the pipe chain ('collect', 'first').
  * @returns {Object} - An object with a `close` method that removes the pipeline between the two event emitters.
  * @throws {TypeError} - If either of the arguments is not an event emitter object.
  */
-function pipeAsync(e1, e2 /* , name */) {
+function pipeAsync(e1, e2 /* , name, options */) {
   let pipes;
   (0, _validObject.default)(e1) && (0, _validObject.default)(e2);
   let name = arguments[2];
+  let options = arguments[3];
+  if (typeof name === 'object') {
+    options = name;
+    name = undefined;
+  }
   if (name === undefined) {
     name = 'emitAsync';
   }
+  if (!options) {
+    options = {};
+  }
   const result = {
     close() {
       _arrayRemove.default.call(pipes, e2);
@@ -50,9 +61,32 @@ function pipeAsync(e1, e2 /* , name */) {
   }
   desc.value = async function () {
     const data = arrFrom(pipes);
-    await emit.apply(this, arguments);
-    let emitter;
-    for (let i = 0; emitter = data[i]; ++i) await emit.apply(emitter, arguments);
+    const asyncMode = options.asyncMode || 'serial';
+    const resultMode = options.resultMode;
+    const forward = async (target, args) => {
+      const fn = target[name] || target.emitAsync || emit;
+      return fn.apply(target, args);
+    };
+    if (asyncMode === 'parallel') {
+      const promises = [emit.apply(this, arguments)];
+      for (let i = 0; i < data.length; ++i) {
+        promises.push(forward(data[i], arguments));
+      }
+      const results = await Promise.all(promises);
+      if (resultMode === 'collect') return results;
+      if (resultMode === 'first') return results.find(r => r !== undefined);
+      return results[0]; // Default: return main emitter's result
+    } else {
+      const mainResult = await emit.apply(this, arguments);
+      const allResults = [mainResult];
+      for (let i = 0; i < data.length; ++i) {
+        const res = await forward(data[i], arguments);
+        allResults.push(res);
+      }
+      if (resultMode === 'collect') return allResults;
+      if (resultMode === 'first') return allResults.find(r => r !== undefined);
+      return mainResult; // Default: return main emitter's result
+    }
   };
   (0, _defineProperty.default)(e1, name, desc.value, desc);
   return result;

package/lib/pipe.d.ts

@@ -7,5 +7,5 @@
  * @returns {Object} - An object with a `close` method that removes the pipeline between the two event emitters.
  * @throws {TypeError} - If either of the arguments is not an event emitter object.
  */
-export function pipe(e1: import('./event-emitter').EventEmitter, e2: import('./event-emitter').EventEmitter, ...args: any[]): any;
+export function pipe(e1: import("./event-emitter").EventEmitter, e2: import("./event-emitter").EventEmitter, ...args: any[]): any;
 export default pipe;

package/lib/pipe.js

@@ -9,7 +9,7 @@ var _defineProperty = _interopRequireDefault(require("util-ex/lib/defineProperty
 var _wrapEventEmitter = require("./wrap-event-emitter");
 var _arrayRemove = _interopRequireDefault(require("./util/array-remove"));
 var _validObject = _interopRequireDefault(require("./util/valid-object"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
 const arrFrom = Array.from;

package/lib/unify.d.ts

@@ -5,5 +5,5 @@
  * @param {import('./event-emitter').EventEmitter} e2 - The second event emitter object.
  * @throws {TypeError} - If either of the arguments is not an event emitter object.
  */
-export function unify(e1: import('./event-emitter').EventEmitter, e2: import('./event-emitter').EventEmitter): void;
+export function unify(e1: import("./event-emitter").EventEmitter, e2: import("./event-emitter").EventEmitter): void;
 export default unify;

package/lib/unify.js

@@ -7,7 +7,7 @@ exports.default = void 0;
 exports.unify = unify;
 var _validObject = _interopRequireDefault(require("./util/valid-object"));
 var _objectForEach = _interopRequireDefault(require("./util/object-for-each"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const push = Array.prototype.apply;
 const defineProperty = Object.defineProperty;
 const create = Object.create;

package/lib/util/array-remove.js

@@ -8,7 +8,7 @@ exports.remove = remove;
 const indexOf = Array.prototype.indexOf;
 const forEach = Array.prototype.forEach;
 const splice = Array.prototype.splice;
-function remove( /* ...itemsToRemove */
+function remove(/* ...itemsToRemove */
 ) {
   forEach.call(arguments, function (item) {
     const index = indexOf.call(this, item);

package/lib/util/object-for-each.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 exports.forEach = forEach;
 var _validObject = _interopRequireDefault(require("./valid-object"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const bind = Function.prototype.bind;
 const keys = Object.keys;
 function forEach(obj, cb /* , thisArg, compareFn */) {

package/lib/util/promise-any.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/util/promise-any.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/**
+ * Simple polyfill for AggregateError if it doesn't exist.
+ */
+const _AggregateError = typeof AggregateError !== 'undefined' ? AggregateError : function AggregateError(errors, message) {
+  const error = new Error(message);
+  error.name = 'AggregateError';
+  error.errors = errors;
+  return error;
+};
+
+/**
+ * Ensures Promise.any exists, or provides a polyfill.
+ */
+if (typeof Promise.any !== 'function') {
+  Promise.any = function (promises) {
+    return new Promise((resolve, reject) => {
+      promises = Array.from(promises);
+      const len = promises.length;
+      let errors = [];
+      let rejectedCount = 0;
+      if (len === 0) {
+        return reject(new _AggregateError(errors, 'All promises were rejected'));
+      }
+      promises.forEach((promise, index) => {
+        Promise.resolve(promise).then(value => {
+          resolve(value);
+        }).catch(error => {
+          errors[index] = error;
+          rejectedCount++;
+          if (rejectedCount === len) {
+            reject(new _AggregateError(errors, 'All promises were rejected'));
+          }
+        });
+      });
+    });
+  };
+}
+var _default = exports.default = Promise.any;

package/lib/util/string-pad.js

@@ -7,7 +7,7 @@ exports.default = void 0;
 exports.pad = pad;
 var _toInt = _interopRequireDefault(require("./to-int"));
 var _validObject = _interopRequireDefault(require("./valid-object"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const repeat = String.prototype.repeat;
 const abs = Math.abs;
 const max = Math.max;

package/lib/wrap-event-emitter.d.ts

@@ -1,8 +1,9 @@
 /**
  * Create or inject the eventable instance into the object
  * @param {Object} [o] the optional instance to eventable
+ * @param {Object} [options] optional configuration for the emitter
  * @returns o or new Event instance
  */
-export function wrapEventEmitter(o?: any): any;
+export function wrapEventEmitter(o?: any, options?: any): any;
 export const methods: any;
 export default wrapEventEmitter;

package/lib/wrap-event-emitter.js

@@ -7,10 +7,14 @@ exports.methods = exports.default = void 0;
 exports.wrapEventEmitter = wrapEventEmitter;
 var _utilEx = require("util-ex");
 var _eventable = _interopRequireDefault(require("./eventable"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const create = Object.create;
 const defineProperties = Object.defineProperties;
 const methods = exports.methods = (0, _eventable.default)().methods;
+
+/**
+ * Minimal set of core methods to be injected into an existing object.
+ */
 const descriptors = {
   on: {
     value: methods.on
@@ -26,18 +30,35 @@ const descriptors = {
   },
   emitAsync: {
     value: methods.emitAsync
+  },
+  setEmitterOptions: {
+    value: methods.setEmitterOptions
   }
 };
-const base = defineProperties({}, descriptors);
+
+/**
+ * Full set of all available methods from eventable for standalone instances.
+ */
+const fullDescriptors = {};
+Object.keys(methods).forEach(key => {
+  fullDescriptors[key] = {
+    value: methods[key]
+  };
+});
+const base = defineProperties({}, fullDescriptors);
 
 /**
  * Create or inject the eventable instance into the object
  * @param {Object} [o] the optional instance to eventable
+ * @param {Object} [options] optional configuration for the emitter
  * @returns o or new Event instance
  */
-function wrapEventEmitter(o) {
+function wrapEventEmitter(o, options) {
   const result = o == null ? create(base) : defineProperties(Object(o), descriptors);
   (0, _utilEx.defineProperty)(result, '_events', {});
+  if (options && options.emitterOptions) {
+    result.setEmitterOptions(options.emitterOptions);
+  }
   return result;
 }
 ;