events-ex 2.3.0 → 2.4.0

package/lib/event.d.ts

@@ -25,19 +25,25 @@ export class Event {
      * @type {Object}
      * @public
      */
-    public target: any;
+    public target: Object | undefined;
     /**
      * Whether stop the bubbling event
      * @type {boolean}
      * @public
      */
-    public stopped: boolean;
+    public stopped: boolean | undefined;
+    /**
+     * Whether the event emission was aborted via AbortSignal.
+     * @type {boolean}
+     * @public
+     */
+    public aborted: boolean | undefined;
     /**
      * Whether a result has been resolved (for 'first' result mode)
      * @type {boolean}
      * @public
      */
-    public resolved: boolean;
+    public resolved: boolean | undefined;
     /**
      * Keep your event result here if any.
      * @type {*}
@@ -49,7 +55,7 @@ export class Event {
      * @type {string}
      * @public
      */
-    public type: string;
+    public type: string | undefined;
     /**
      * Ends the event and returns the result.
      * @returns {*} The result of the event.

package/lib/event.js

@@ -37,6 +37,12 @@ Event.prototype.init = function (target, type) {
    * @public
    */
   this.stopped = false;
+  /**
+   * Whether the event emission was aborted via AbortSignal.
+   * @type {boolean}
+   * @public
+   */
+  this.aborted = false;
   /**
    * Whether a result has been resolved (for 'first' result mode)
    * @type {boolean}

package/lib/event.mjs

@@ -0,0 +1,67 @@
+/**
+ * Creates a new Event object instance that contains information about the event, such as the target element and the return value of the event.
+ * @class
+ * @classdesc Event Object that contains information about the event, such as the target element and the return value of the event.
+ * @param {import('./event-emitter').EventEmitter} target - Who trigger the event
+ * @returns {Event} - The new Event instance.
+ */
+export function Event(target, type) {
+  if (!(this instanceof Event)) {
+    const evt = new Event(target, type)
+    return evt
+  }
+  this.init(target, type)
+}
+
+/**
+ * Initializes the event with the target object.
+ * @param {import('./event-emitter').EventEmitter} target - The target object for the event.
+ */
+Event.prototype.init = function(target, type) {
+  /**
+   * Who trigger the event
+   * @type {Object}
+   * @public
+   */
+  this.target = target
+  /**
+   * Whether stop the bubbling event
+   * @type {boolean}
+   * @public
+   */
+  this.stopped = false
+  /**
+   * Whether the event emission was aborted via AbortSignal.
+   * @type {boolean}
+   * @public
+   */
+  this.aborted = 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 {*}
+   * @public
+   */
+  this.result = undefined
+  /**
+   * The type of the event.
+   * @type {string}
+   * @public
+   */
+  this.type = type;
+}
+
+/**
+ * Ends the event and returns the result.
+ * @returns {*} The result of the event.
+ */
+Event.prototype.end = function() {
+  return this.result
+}
+
+export default Event

package/lib/eventable.d.ts

@@ -45,7 +45,7 @@
  *   }
  * });
  */
-export const eventable: <T extends Function | (new (...args: any[]) => any)>(targetClass?: T, options?: import("custom-ability").AbilityOptions) => T & typeof getEventableClass & (T extends new (...args: any[]) => any ? InstanceType<T> : T);
+export const eventable: <T extends Function | (new (...args: any[]) => any)>(targetClass?: T | undefined, options?: import("custom-ability").AbilityOptions) => T & typeof getEventableClass & (T extends new (...args: any[]) => any ? InstanceType<T> : T);
 export default eventable;
 /**
  * Creates an Eventable class with event-emitting capabilities.

package/lib/eventable.mjs

@@ -0,0 +1,90 @@
+import {createAbilityInjector} from 'custom-ability'
+import defineProperty from 'util-ex/lib/defineProperty'
+import defaultMethods from './default-methods.mjs'
+
+/**
+ * Creates an Eventable class with event-emitting capabilities.
+ *
+ * @param {Function} [aClass] - The target class to which event capabilities will be injected.
+ *                              If not provided, a new base class (`Eventable`) is created and used.
+ * @returns {Function} A class with event-emitting capabilities.
+ */
+function getEventableClass(aClass) {
+  /**
+   * Base Eventable class that provides event-related functionality.
+   * @class
+   */
+  function Eventable() {}
+
+  if (aClass == null) {aClass = Eventable}
+  const methods = defaultMethods(aClass);
+  defineProperty(Eventable, 'methods', methods);
+
+  Eventable.defaultMaxListeners = 10;
+  Eventable.listenerCount = methods.listenerCount;
+  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;
+  Eventable.prototype.removeListener = methods.off;
+  Eventable.prototype.removeAllListeners = methods.removeAllListeners;
+  Eventable.prototype.once = methods.once;
+  Eventable.prototype.setMaxListeners = methods.setMaxListeners;
+  Eventable.prototype.listeners = methods.listeners;
+  return Eventable;
+};
+
+/**
+ * Adds event-emitting capabilities to a class by injecting necessary methods and properties.
+ *
+ * This function uses `createAbilityInjector` from `custom-ability` to inject event-related methods
+ * into the target class. The injected methods include standard EventEmitter functionality such as
+ * `on`, `off`, `emit`, `emitAsync`, `once`, `listeners`, `@listenerCount` and more. It also ensures compatibility with Node.js `EventEmitter`
+ * by including methods like `listenerCount`, `setMaxListeners`, `addListener`, `removeListener`, and `removeAllListeners`.
+ *
+ * @function eventable
+ * @param {Class} [aClass] - The target class to which event capabilities will be injected. if no class is provided, a new class with eventable will be created.
+ * @param {Object} [options] - Optional configuration for the injection process:
+ *   * `include` (string[]|string): Specifies which methods should be added.
+ *     Static methods should use the prefix '@'.
+ *   * `exclude` (string[]|string): Specifies which methods should not be added.
+ *     Static methods should use the prefix '@'.
+ *   * `methods` (Object): Custom methods to override or extend the default behavior.
+ *     Use `this.super()` to call the original method and `this.self` to access the original context.
+ *   * `classMethods` (Object): Custom static methods to be added to the class.
+ * @returns {Class} The same `aClass` class with event capabilities injected. The return value is the modified `aClass` itself.
+ *
+ * @example
+ * import { eventable } from 'events-ex';
+ *
+ * class MyClass {}
+ *
+ * // Inject only specific methods: 'on', 'off', 'emit', 'emitAsync', and the static 'listenerCount'
+ * eventable(MyClass, { include: ['on', 'off', 'emit', 'emitAsync', '@listenerCount'] });
+ *
+ * @example
+ * import { eventable } from 'events-ex';
+ *
+ * class OtherClass {
+ *   exec() {
+ *     console.log("Original exec");
+ *   }
+ * }
+ *
+ * // Inject event capabilities and override the `exec` method
+ * eventable(OtherClass, {
+ *   methods: {
+ *     exec() {
+ *       console.log("New exec");
+ *       this.super(); // Calls the original `exec` method
+ *     }
+ *   }
+ * });
+ */
+export const eventable = createAbilityInjector(getEventableClass, true);
+export default eventable;

package/lib/has-listeners.d.ts

@@ -8,5 +8,5 @@
  *          - If `type` is not provided, returns whether the object has any event listeners.
  * @throws {TypeError} Throws a TypeError if `obj` is null or undefined.
  */
-export function hasListeners(obj: any, type?: string): boolean;
+export function hasListeners(obj: Object, type?: string): boolean;
 export default hasListeners;

package/lib/has-listeners.mjs

@@ -0,0 +1,27 @@
+
+import {isEmptyObject} from 'util-ex'
+
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function isValue(v) {
+	return v!== null && v!== undefined
+}
+
+/**
+ * Checks if an object has event listeners.
+ *
+ * @param {Object} obj - The object to check. Must not be null or undefined.
+ * @param {string} [type] - Optional parameter specifying the event type. If provided, checks for the existence of listeners for this specific type.
+ * @returns {boolean}
+ *          - If `type` is provided, returns whether listeners for the specified event type exist.
+ *          - If `type` is not provided, returns whether the object has any event listeners.
+ * @throws {TypeError} Throws a TypeError if `obj` is null or undefined.
+ */
+export function hasListeners(obj, type) {
+	if (!isValue(obj)) {throw new TypeError("Cannot use null or undefined")}
+
+	const result = type != null ? hasOwnProperty.call(obj, '_events') && obj._events[type] : obj.hasOwnProperty('_events') && !isEmptyObject(obj._events);
+	return result;
+};
+
+export default hasListeners

package/lib/index.d.ts

@@ -6,6 +6,7 @@ export * from "./event-emitter";
 export * from "./has-listeners";
 export * from "./pipe";
 export * from "./pipe-async";
+export * from "./once-promise";
 export * from "./unify";
 export * from "./wrap-event-emitter";
 export default EventEmitter;

package/lib/index.js

@@ -101,6 +101,18 @@ Object.keys(_pipeAsync).forEach(function (key) {
     }
   });
 });
+var _oncePromise = require("./once-promise");
+Object.keys(_oncePromise).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _oncePromise[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _oncePromise[key];
+    }
+  });
+});
 var _unify = require("./unify");
 Object.keys(_unify).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/lib/index.mjs

@@ -0,0 +1,16 @@
+// @sourceType: module
+import {EventEmitter} from './event-emitter.mjs'
+
+export * from './all-off.mjs'
+export * from './consts.mjs'
+export * from './event.mjs'
+export * from './eventable.mjs'
+export * from './event-emitter.mjs'
+export * from './has-listeners.mjs'
+export * from './pipe.mjs'
+export * from './pipe-async.mjs'
+export * from './once-promise.mjs'
+export * from './unify.mjs'
+export * from './wrap-event-emitter.mjs'
+
+export default EventEmitter;

package/lib/once-promise.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Returns a Promise that resolves with the Event object when the specified event is emitted on the given emitter.
+ * If an 'error' event is emitted (and the waiting event is not 'error'), the promise rejects by default.
+ * If the provided AbortSignal is aborted, the promise rejects with an AbortError.
+ *
+ * Note: The resolved Event object's `result` field may not be the final value if other listeners have not yet run.
+ * For the definitive emit return value, use `emit()` or `emitAsync()` directly.
+ *
+ * @param {import('./event-emitter').EventEmitter} emitter - The event emitter to listen on.
+ * @param {string|RegExp} type - The event type to wait for.
+ * @param {Object} [options] - Optional configuration.
+ * @param {AbortSignal} [options.signal] - An AbortSignal to cancel the wait.
+ * @param {boolean|null} [options.raiseError] - Controls behavior when an 'error' event is emitted:
+ *   - `true` / `undefined` (default): The promise rejects with the error.
+ *   - `false`: The promise resolves with the error object instead of rejecting.
+ * @returns {Promise<import('./event').Event>} - A promise that resolves with the Event object.
+ * @throws {TypeError} - If emitter is not a valid event emitter object.
+ */
+export function oncePromise(emitter: import("./event-emitter").EventEmitter, type: string | RegExp, options?: {
+    signal?: any;
+    raiseError?: boolean | null | undefined;
+}): Promise<import("./event").Event>;
+export default oncePromise;

package/lib/once-promise.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.oncePromise = oncePromise;
+var _validObject = _interopRequireDefault(require("./util/valid-object"));
+var _consts = require("./consts");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// @sourceType: module
+
+/**
+ * Returns a Promise that resolves with the Event object when the specified event is emitted on the given emitter.
+ * If an 'error' event is emitted (and the waiting event is not 'error'), the promise rejects by default.
+ * If the provided AbortSignal is aborted, the promise rejects with an AbortError.
+ *
+ * Note: The resolved Event object's `result` field may not be the final value if other listeners have not yet run.
+ * For the definitive emit return value, use `emit()` or `emitAsync()` directly.
+ *
+ * @param {import('./event-emitter').EventEmitter} emitter - The event emitter to listen on.
+ * @param {string|RegExp} type - The event type to wait for.
+ * @param {Object} [options] - Optional configuration.
+ * @param {AbortSignal} [options.signal] - An AbortSignal to cancel the wait.
+ * @param {boolean|null} [options.raiseError] - Controls behavior when an 'error' event is emitted:
+ *   - `true` / `undefined` (default): The promise rejects with the error.
+ *   - `false`: The promise resolves with the error object instead of rejecting.
+ * @returns {Promise<import('./event').Event>} - A promise that resolves with the Event object.
+ * @throws {TypeError} - If emitter is not a valid event emitter object.
+ */
+function oncePromise(emitter, type, options) {
+  (0, _validObject.default)(emitter);
+  const signal = options && options.signal;
+  const raiseError = options && options.raiseError;
+  return new Promise((resolve, reject) => {
+    let onAbort = null;
+    let aborted = false;
+    const cleanup = () => {
+      emitter.off(type, onEvent);
+      if (type !== 'error') {
+        emitter.off('error', onError);
+      }
+      if (signal && onAbort) {
+        signal.removeEventListener('abort', onAbort);
+      }
+    };
+    if (signal) {
+      if (signal.aborted) {
+        reject((0, _consts.createAbortError)());
+        return;
+      }
+      onAbort = () => {
+        /* v8 ignore next — defensive guard, { once: true } ensures callback fires at most once */
+        if (!aborted) {
+          aborted = true;
+          cleanup();
+          reject((0, _consts.createAbortError)());
+        }
+      };
+      signal.addEventListener('abort', onAbort, {
+        once: true
+      });
+    }
+    function onEvent() {
+      cleanup();
+      resolve(this); // resolve with the Event object
+    }
+    function onError(err) {
+      cleanup();
+      if (raiseError === false) {
+        resolve(err); // resolve with the error instead of rejecting
+      } else {
+        reject(err); // true | null | undefined → reject
+      }
+    }
+    emitter.on(type, onEvent);
+    if (type !== 'error') {
+      emitter.on('error', onError);
+    }
+  });
+}
+var _default = exports.default = oncePromise;

package/lib/once-promise.mjs

@@ -0,0 +1,80 @@
+// @sourceType: module
+import validObject from './util/valid-object.mjs'
+import {createAbortError} from './consts.mjs'
+
+/**
+ * Returns a Promise that resolves with the Event object when the specified event is emitted on the given emitter.
+ * If an 'error' event is emitted (and the waiting event is not 'error'), the promise rejects by default.
+ * If the provided AbortSignal is aborted, the promise rejects with an AbortError.
+ *
+ * Note: The resolved Event object's `result` field may not be the final value if other listeners have not yet run.
+ * For the definitive emit return value, use `emit()` or `emitAsync()` directly.
+ *
+ * @param {import('./event-emitter').EventEmitter} emitter - The event emitter to listen on.
+ * @param {string|RegExp} type - The event type to wait for.
+ * @param {Object} [options] - Optional configuration.
+ * @param {AbortSignal} [options.signal] - An AbortSignal to cancel the wait.
+ * @param {boolean|null} [options.raiseError] - Controls behavior when an 'error' event is emitted:
+ *   - `true` / `undefined` (default): The promise rejects with the error.
+ *   - `false`: The promise resolves with the error object instead of rejecting.
+ * @returns {Promise<import('./event').Event>} - A promise that resolves with the Event object.
+ * @throws {TypeError} - If emitter is not a valid event emitter object.
+ */
+export function oncePromise(emitter, type, options) {
+  validObject(emitter)
+
+  const signal = options && options.signal
+  const raiseError = options && options.raiseError
+
+  return new Promise((resolve, reject) => {
+    let onAbort = null
+    let aborted = false
+
+    const cleanup = () => {
+      emitter.off(type, onEvent)
+      if (type !== 'error') {
+        emitter.off('error', onError)
+      }
+      if (signal && onAbort) {
+        signal.removeEventListener('abort', onAbort)
+      }
+    }
+
+    if (signal) {
+      if (signal.aborted) {
+        reject(createAbortError())
+        return
+      }
+      onAbort = () => {
+        /* v8 ignore next — defensive guard, { once: true } ensures callback fires at most once */
+        if (!aborted) {
+          aborted = true
+          cleanup()
+          reject(createAbortError())
+        }
+      }
+      signal.addEventListener('abort', onAbort, { once: true })
+    }
+
+    function onEvent() {
+      cleanup()
+      resolve(this) // resolve with the Event object
+    }
+
+    function onError(err) {
+      cleanup()
+      if (raiseError === false) {
+        resolve(err) // resolve with the error instead of rejecting
+      } else {
+        reject(err) // true | null | undefined → reject
+      }
+    }
+
+    emitter.on(type, onEvent)
+    if (type !== 'error') {
+      emitter.on('error', onError)
+    }
+  })
+}
+
+export default oncePromise

package/lib/pipe-async.d.ts

@@ -6,9 +6,11 @@
  * @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').
+ * @param {string} [options.resultMode='last'] - Strategy for aggregating results from the pipe chain ('last', 'first', 'collect').
+ * @param {AbortSignal} [options.signal] - An AbortSignal to cancel forwarding to remaining pipe targets (serial mode only).
+ *   Can also be set on the source emitter via `configure({ signal })`.
  * @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[]): Object;
 export default pipeAsync;

package/lib/pipe-async.js

@@ -23,7 +23,9 @@ const emit = _wrapEventEmitter.methods.emitAsync;
  * @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').
+ * @param {string} [options.resultMode='last'] - Strategy for aggregating results from the pipe chain ('last', 'first', 'collect').
+ * @param {AbortSignal} [options.signal] - An AbortSignal to cancel forwarding to remaining pipe targets (serial mode only).
+ *   Can also be set on the source emitter via `configure({ signal })`.
  * @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.
  */
@@ -67,6 +69,9 @@ function pipeAsync(e1, e2 /* , name, options */) {
       const fn = target[name] || target.emitAsync || emit;
       return fn.apply(target, args);
     };
+
+    // Read signal from source emitter's runtime options, if configured
+    const signal = this._eeRuntimeOptions && this._eeRuntimeOptions.signal;
     if (asyncMode === 'parallel') {
       const promises = [emit.apply(this, arguments)];
       for (let i = 0; i < data.length; ++i) {
@@ -75,17 +80,25 @@ function pipeAsync(e1, e2 /* , name, options */) {
       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
+      // Default: 'last' — return last non-undefined result in the pipe chain
+      for (let i = results.length - 1; i >= 0; i--) {
+        if (results[i] !== undefined) return results[i];
+      }
     } else {
       const mainResult = await emit.apply(this, arguments);
       const allResults = [mainResult];
       for (let i = 0; i < data.length; ++i) {
+        // Check signal before forwarding to each pipe target in serial mode
+        if (signal && signal.aborted) break;
         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
+      // Default: 'last' — return last non-undefined result in the pipe chain
+      for (let i = allResults.length - 1; i >= 0; i--) {
+        if (allResults[i] !== undefined) return allResults[i];
+      }
     }
   };
   (0, _defineProperty.default)(e1, name, desc.value, desc);

package/lib/pipe-async.mjs

@@ -0,0 +1,100 @@
+import defineProperty from 'util-ex/lib/defineProperty'
+
+import {methods} from './wrap-event-emitter.mjs'
+import arrRemove from './util/array-remove.mjs'
+import validObject from './util/valid-object.mjs'
+
+const hasOwnProperty = Object.prototype.hasOwnProperty
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor
+const arrFrom        = Array.from
+const emit           = methods.emitAsync
+
+/**
+ * Creates a pipeline between two event emitters, so that any events emitted by the first emitter are also emitted by the second emitter.
+ *
+ * @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='last'] - Strategy for aggregating results from the pipe chain ('last', 'first', 'collect').
+ * @param {AbortSignal} [options.signal] - An AbortSignal to cancel forwarding to remaining pipe targets (serial mode only).
+ *   Can also be set on the source emitter via `configure({ signal })`.
+ * @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, e2/* , name, options */) {
+  let pipes
+
+  (validObject(e1) && validObject(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() { arrRemove.call(pipes, e2) }
+  };
+  if (hasOwnProperty.call(e1, '__eePipes__')) {
+    (pipes = e1.__eePipes__).push(e2)
+    return result
+  }
+  defineProperty(e1, '__eePipes__', pipes = [e2])
+  let desc = getOwnPropertyDescriptor(e1, name)
+  if (!desc) {
+    desc = {}
+  } else {
+    delete desc.get
+    delete desc.set
+  }
+  desc.value = async function () {
+    const data = arrFrom(pipes)
+    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)
+    }
+
+    // Read signal from source emitter's runtime options, if configured
+    const signal = this._eeRuntimeOptions && this._eeRuntimeOptions.signal
+
+    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)
+      // Default: 'last' — return last non-undefined result in the pipe chain
+      for (let i = results.length - 1; i >= 0; i--) {
+        if (results[i] !== undefined) return results[i]
+      }
+    } else {
+      const mainResult = await emit.apply(this, arguments)
+      const allResults = [mainResult]
+      for (let i = 0; i < data.length; ++i) {
+        // Check signal before forwarding to each pipe target in serial mode
+        if (signal && signal.aborted) break
+        const res = await forward(data[i], arguments)
+        allResults.push(res)
+      }
+      if (resultMode === 'collect') return allResults
+      if (resultMode === 'first') return allResults.find(r => r !== undefined)
+      // Default: 'last' — return last non-undefined result in the pipe chain
+      for (let i = allResults.length - 1; i >= 0; i--) {
+        if (allResults[i] !== undefined) return allResults[i]
+      }
+    }
+  }
+  defineProperty(e1, name, desc.value, desc)
+  return result
+};
+
+export default pipeAsync

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[]): Object;
 export default pipe;