@daiso-tech/core 0.33.0 → 0.35.0

package/dist/async/middlewares/timeout/timeout.middleware.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @module Async
+ */
+import { TimeSpan } from "../../../utilities/_module-exports.js";
+import { type AsyncMiddlewareFn, type HookContext } from "../../../utilities/_module-exports.js";
+import { type Invokable } from "../../../utilities/_module-exports.js";
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ */
+export type OnTimeoutData<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
+    waitTime: TimeSpan;
+    args: TParameters;
+    context: TContext;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ */
+export type OnTimeout<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = Invokable<[data: OnTimeoutData<TParameters, TContext>]>;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ */
+export type TimeoutCallbacks<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
+    /**
+     * Callback function that will be called when the timeout occurs.
+     */
+    onTimeout?: OnTimeout<TParameters, TContext>;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ */
+export type TimeoutSettings<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = TimeoutCallbacks<TParameters, TContext> & {
+    /**
+     * The maximum time to wait before automatically aborting the executing function.
+     *
+     * @default
+     * ```ts
+     * import { TimeSpan } from "@daiso-tech/core/utilities";
+     *
+     * TimeSpan.fromSeconds(2)
+     * ```
+     */
+    waitTime?: TimeSpan;
+};
+/**
+ * The `timeout` middleware automatically cancels functions after a specified time period, throwing an error when aborted.
+ * Note the original function continues executing (even if the promise fails), you'll need to provide a settings.signalBinder to forward the `AbortSignal`.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}
+ *
+ * @example
+ * ```ts
+ * import { timeout } from "@daiso-tech/core/async";
+ * import { AsyncHooks, TimeSpan } from "@daiso-tech/core/utilities";
+ *
+ * const data = await new AsyncHooks(
+ *   async (url: string, signal?: AbortSignal): Promise<unknown> => {
+ *     const response = await fetch(url, { signal });
+ *     return await response.json();
+ *   },
+ *   [timeout({ waitTime: TimeSpan.fromSeconds(2) })],
+ *   {
+ *     signalBinder: {
+ *       getSignal: (args) => args[1],
+ *       forwardSignal: (args, signal) => {
+ *         args[1] = signal;
+ *       }
+ *     }
+ *   }
+ * )
+ * .invoke("URL");
+ * ```
+ */
+export declare function timeout<TParameters extends unknown[], TReturn, TContext extends HookContext>(settings?: NoInfer<TimeoutSettings<TParameters, TContext>>): AsyncMiddlewareFn<TParameters, TReturn, TContext>;

package/dist/async/middlewares/timeout/timeout.middleware.js

@@ -0,0 +1,60 @@
+/**
+ * @module Async
+ */
+import { TimeSpan } from "../../../utilities/_module-exports.js";
+import {} from "../../../utilities/_module-exports.js";
+import { callInvokable } from "../../../utilities/_module-exports.js";
+import { TimeoutAsyncError } from "../../../async/async.errors.js";
+import { timeoutAndFail } from "../../../async/utilities/_module.js";
+/**
+ * The `timeout` middleware automatically cancels functions after a specified time period, throwing an error when aborted.
+ * Note the original function continues executing (even if the promise fails), you'll need to provide a settings.signalBinder to forward the `AbortSignal`.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}
+ *
+ * @example
+ * ```ts
+ * import { timeout } from "@daiso-tech/core/async";
+ * import { AsyncHooks, TimeSpan } from "@daiso-tech/core/utilities";
+ *
+ * const data = await new AsyncHooks(
+ *   async (url: string, signal?: AbortSignal): Promise<unknown> => {
+ *     const response = await fetch(url, { signal });
+ *     return await response.json();
+ *   },
+ *   [timeout({ waitTime: TimeSpan.fromSeconds(2) })],
+ *   {
+ *     signalBinder: {
+ *       getSignal: (args) => args[1],
+ *       forwardSignal: (args, signal) => {
+ *         args[1] = signal;
+ *       }
+ *     }
+ *   }
+ * )
+ * .invoke("URL");
+ * ```
+ */
+export function timeout(settings = {}) {
+    const { waitTime = TimeSpan.fromSeconds(2), onTimeout = () => { } } = settings;
+    return async (args, next, { context, abort, signal }) => {
+        try {
+            return await timeoutAndFail(next(...args), waitTime, (error) => {
+                abort(error);
+            }, signal);
+        }
+        catch (error) {
+            if (error instanceof TimeoutAsyncError) {
+                callInvokable(onTimeout, {
+                    args,
+                    context,
+                    waitTime,
+                });
+            }
+            throw error;
+        }
+    };
+}
+//# sourceMappingURL=timeout.middleware.js.map

package/dist/async/middlewares/timeout/timeout.middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.middleware.js","sourceRoot":"","sources":["../../../../src/async/middlewares/timeout/timeout.middleware.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAC1D,OAAO,EAGN,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,aAAa,EAAkB,MAAM,gCAAgC,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AA+D9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,OAAO,CAKnB,WAA4D,EAAE;IAE9D,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,SAAS,GAAG,GAAG,EAAE,GAAE,CAAC,EAAE,GAC9D,QAAQ,CAAC;IACb,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE;QACpD,IAAI,CAAC;YACD,OAAO,MAAM,cAAc,CACvB,IAAI,CAAC,GAAG,IAAI,CAAC,EACb,QAAQ,EACR,CAAC,KAAc,EAAE,EAAE;gBACf,KAAK,CAAC,KAAK,CAAC,CAAC;YACjB,CAAC,EACD,MAAM,CACT,CAAC;QACN,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACtB,IAAI,KAAK,YAAY,iBAAiB,EAAE,CAAC;gBACrC,aAAa,CAAC,SAAS,EAAE;oBACrB,IAAI;oBACJ,OAAO;oBACP,QAAQ;iBACX,CAAC,CAAC;YACP,CAAC;YACD,MAAM,KAAK,CAAC;QAChB,CAAC;IACL,CAAC,CAAC;AACN,CAAC"}

package/dist/async/utilities/_module.d.ts

@@ -1,5 +1,4 @@
-export * from "../../async/utilities/abort/_module.js";
-export * from "../../async/utilities/delay/_module.js";
+export * from "../../async/utilities/abort-and-fail/_module.js";
 export * from "../../async/utilities/lazy-promise/_module.js";
-export * from "../../async/utilities/retry/_module.js";
-export * from "../../async/utilities/timeout/_module.js";
+export * from "../../async/utilities/promise-queue/_module.js";
+export * from "../../async/utilities/timeout-and-fail/_module.js";

package/dist/async/utilities/_module.js

@@ -1,6 +1,5 @@
-export * from "../../async/utilities/abort/_module.js";
-export * from "../../async/utilities/delay/_module.js";
+export * from "../../async/utilities/abort-and-fail/_module.js";
 export * from "../../async/utilities/lazy-promise/_module.js";
-export * from "../../async/utilities/retry/_module.js";
-export * from "../../async/utilities/timeout/_module.js";
+export * from "../../async/utilities/promise-queue/_module.js";
+export * from "../../async/utilities/timeout-and-fail/_module.js";
 //# sourceMappingURL=_module.js.map

package/dist/async/utilities/_module.js.map

@@ -1 +1 @@
-{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../src/async/utilities/_module.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,oCAAoC,CAAC;AACnD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,oCAAoC,CAAC;AACnD,cAAc,sCAAsC,CAAC"}
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../src/async/utilities/_module.ts"],"names":[],"mappings":"AAAA,cAAc,6CAA6C,CAAC;AAC5D,cAAc,2CAA2C,CAAC;AAC1D,cAAc,4CAA4C,CAAC;AAC3D,cAAc,+CAA+C,CAAC"}

package/dist/async/utilities/abort-and-fail/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../async/utilities/abort-and-fail/abort-and-fail.js";

package/dist/async/utilities/abort-and-fail/_module.js

@@ -0,0 +1,2 @@
+export * from "../../../async/utilities/abort-and-fail/abort-and-fail.js";
+//# sourceMappingURL=_module.js.map

package/dist/async/utilities/abort-and-fail/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../src/async/utilities/abort-and-fail/_module.ts"],"names":[],"mappings":"AAAA,cAAc,oDAAoD,CAAC"}

package/dist/async/utilities/abort-and-fail/abort-and-fail.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module Async
+ */
+/**
+ * @internal
+ */
+export declare function abortAndFail<TValue>(promise: PromiseLike<TValue>, abortSignal: AbortSignal): Promise<TValue>;

package/dist/async/utilities/{abort → abort-and-fail}/abort-and-fail.js

@@ -1,7 +1,6 @@
 /**
  * @module Async
  */
-import { AbortAsyncError } from "../../../async/async.errors.js";
 /**
  * @internal
  */
@@ -11,11 +10,12 @@ function abortSignalToPromise(abortSignal) {
         if (reject_ === null) {
             return;
         }
-        reject_(new AbortAsyncError(`Promise was aborted with reason of "${String(abortSignal.reason)}"`, abortSignal.reason));
+        reject_(abortSignal.reason);
     }
     if (abortSignal.aborted) {
         return {
-            promise: Promise.reject(new AbortAsyncError(`Promise was aborted with reason of "${String(abortSignal.aborted)}"`, abortSignal.reason)),
+            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+            promise: Promise.reject(abortSignal.reason),
             abort,
         };
     }
@@ -36,13 +36,13 @@ function abortSignalToPromise(abortSignal) {
 /**
  * @internal
  */
-export async function abortAndFail(asyncFn, abortSignal) {
+export async function abortAndFail(promise, abortSignal) {
     if (abortSignal.aborted) {
-        throw new AbortAsyncError(`Promise was aborted with reason of "${String(abortSignal.reason)}"`, abortSignal.reason);
+        throw abortSignal.reason;
     }
     const { promise: abortSignalPromise, abort } = abortSignalToPromise(abortSignal);
     try {
-        return await Promise.race([asyncFn(), abortSignalPromise]);
+        return await Promise.race([promise, abortSignalPromise]);
     }
     finally {
         abortSignal.removeEventListener("abort", abort);

package/dist/async/utilities/abort-and-fail/abort-and-fail.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abort-and-fail.js","sourceRoot":"","sources":["../../../../src/async/utilities/abort-and-fail/abort-and-fail.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,SAAS,oBAAoB,CACzB,WAAwB;IAKxB,IAAI,OAAO,GAAsC,IAAI,CAAC;IACtD,SAAS,KAAK;QACV,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;YACnB,OAAO;QACX,CAAC;QACD,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAED,IAAI,WAAW,CAAC,OAAO,EAAE,CAAC;QACtB,OAAO;YACH,2EAA2E;YAC3E,OAAO,EAAE,OAAO,CAAC,MAAM,CAAS,WAAW,CAAC,MAAM,CAAC;YACnD,KAAK;SACR,CAAC;IACN,CAAC;IAED,OAAO;QACH,OAAO,EAAE,IAAI,OAAO,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE;YACtC,OAAO,GAAG,MAAM,CAAC;YACjB,IAAI,WAAW,CAAC,OAAO,EAAE,CAAC;gBACtB,KAAK,EAAE,CAAC;gBACR,OAAO;YACX,CAAC;YACD,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,KAAK,EAAE;gBACzC,IAAI,EAAE,IAAI;aACb,CAAC,CAAC;QACP,CAAC,CAAC;QACF,KAAK;KACR,CAAC;AACN,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAC9B,OAA4B,EAC5B,WAAwB;IAExB,IAAI,WAAW,CAAC,OAAO,EAAE,CAAC;QACtB,MAAM,WAAW,CAAC,MAAM,CAAC;IAC7B,CAAC;IAED,MAAM,EAAE,OAAO,EAAE,kBAAkB,EAAE,KAAK,EAAE,GACxC,oBAAoB,CAAS,WAAW,CAAC,CAAC;IAC9C,IAAI,CAAC;QACD,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC;IAC7D,CAAC;YAAS,CAAC;QACP,WAAW,CAAC,mBAAmB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IACpD,CAAC;AACL,CAAC"}

package/dist/async/utilities/lazy-promise/lazy-promise.d.ts

@@ -1,27 +1,10 @@
 /**
  * @module Async
  */
-import type { BackoffPolicy } from "../../../async/backof-policies/_module.js";
-import type { AsyncLazy, Invokable, InvokableFn, ISyncEventListenable, Promisable, TimeSpan } from "../../../utilities/_module-exports.js";
-import type { RetryPolicy } from "../../../async/utilities/retry/_module.js";
-import { type AsyncEvents } from "../../../async/async.events.js";
-import type { EventClass, EventListener, EventInstance } from "../../../event-bus/contracts/event-bus.contract.js";
+import { type AsyncLazy, type AsyncMiddleware, type Invokable, type InvokableFn, type OneOrMore, type Promisable, type TimeSpan } from "../../../utilities/_module-exports.js";
 /**
  *
- * IMPORT_PATH: ```"@daiso-tech/core/async"```
- * @group Utilities
- */
-export type LazyPromiseSettings = {
-    backoffPolicy?: BackoffPolicy | null;
-    retryAttempts?: number | null;
-    retryPolicy?: RetryPolicy | null;
-    retryTimeout?: TimeSpan | null;
-    totalTimeout?: TimeSpan | null;
-    abortSignal?: AbortSignal | null;
-};
-/**
- *
- * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
  * @group Utilities
  */
 export type LazyPromiseResolve<TValue> = InvokableFn<[
@@ -29,13 +12,13 @@ export type LazyPromiseResolve<TValue> = InvokableFn<[
 ], void>;
 /**
  *
- * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
  * @group Utilities
  */
 export type LazyPromiseReject = InvokableFn<[error: unknown], void>;
 /**
  *
- * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
  * @group Utilities
  */
 export type LazyPromiseCallback<TValue> = InvokableFn<[
@@ -43,49 +26,30 @@ export type LazyPromiseCallback<TValue> = InvokableFn<[
     reject: LazyPromiseReject
 ], Promisable<void>>;
 /**
- * The <i>LazyPromise</i> class is used for creating lazy <i>{@link PromiseLike}<i> object that will only execute when awaited or when then method is called.
- * The class includes helpful methods
- * - <i>defer</i>
- * - <i>setRetryTimeout</i>
- * - <i>setRetryPolicy</i>
- * - <i>setBackoffPolicy</i>
- * - <i>setRetryAttempts</i>
- * - <i>setTotalTimeout</i>
- * - <i>setAbortSignal</i>
- *
- * The order in which these methods are called does not have any affect. Internally, the following execution order is applied:
- * 1. <i>setRetryTimeout</i>
- * 2. <i>setRetryPolicy</i>
- * 3. <i>setBackoffPolicy</i>
- * 4. <i>setRetryAttempts</i>
- * 5. <i>setTotalTimeout</i>
- * 6. <i>setAbortSignal</i>
+ * The `LazyPromise` class is used for creating lazy {@link PromiseLike | `PromiseLike`} object that will only execute when awaited or when `then` method is called.
+ * Note the class is immutable.
  *
- * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
  * @group Utilities
  */
-export declare class LazyPromise<TValue> implements PromiseLike<TValue>, ISyncEventListenable<AsyncEvents<TValue>> {
+export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
     /**
-     * The <i>wrapFn</i> is convience method used for wrapping async <i>{@link Invokable}</i> with a <i>LazyPromise</i>.
+     * The `wrapFn` is convience method used for wrapping async {@link Invokable | `Invokable`} with a `LazyPromise`.
      * @example
      * ```ts
-     * import { LazyPromise } from "@daiso-tech/core/async";
+     * import { LazyPromise, retry } from "@daiso-tech/core/async";
      * import { TimeSpan } from "@daiso-tech/core/utilities";
      * import { readFile as readFileNodeJs } from "node:fs/promises";
      *
      * const readFile = LazyPromise.wrapFn(readFileNodeJs);
      *
-     * const file = await readFile("none_existing_file.txt")
-     *   .setRetryAttempts(4)
-     *   .setRetryTimeout(TimeSpan.fromMinutes(1));
+     * const file = await readFile("none_existing_file.txt");
      * ```
      */
-    static wrapFn<TArgs extends unknown[], TReturn>(fn: Invokable<TArgs, Promisable<TReturn>>, settings?: LazyPromiseSettings): InvokableFn<TArgs, LazyPromise<TReturn>>;
+    static wrapFn<TArgs extends unknown[], TReturn>(fn: Invokable<TArgs, Promisable<TReturn>>): InvokableFn<TArgs, LazyPromise<TReturn>>;
     /**
-     * The <i>delay</i> method creates a <i>{@link LazyPromise}</i> that will be fulfilled after given <i>time</i>.
+     * The `delay` method creates a {@link LazyPromise | `LazyPromise`} that will be fulfilled after given `time`.
      *
-     * @throws {AsyncError} {@link AsyncError}
-     * @throws {AbortAsyncError} {@link AbortAsyncError}
      * @example
      * ```ts
      * import { LazyPromise } from "@daiso-tech/core/async";
@@ -96,25 +60,25 @@ export declare class LazyPromise<TValue> implements PromiseLike<TValue>, ISyncEv
      * console.log("b");
      * ```
      */
-    static delay(time: TimeSpan): LazyPromise<void>;
+    static delay(time: TimeSpan, abortSignal?: AbortSignal): LazyPromise<void>;
     /**
-     * The <i>all<i> method works similarly to <i>{@link Promise.all}</i> with the key distinction that it operates lazily.
+     * The `all` method works similarly to {@link Promise.all | `Promise.all`} with the key distinction that it operates lazily.
      */
-    static all<TValue>(promises: LazyPromise<TValue>[], settings?: LazyPromiseSettings): LazyPromise<TValue[]>;
+    static all<TValue>(promises: LazyPromise<TValue>[]): LazyPromise<TValue[]>;
     /**
-     * The <i>allSettled<i> method works similarly to <i>{@link Promise.allSettled}</i> with the key distinction that it operates lazily.
+     * The `allSettled` method works similarly to {@link Promise.allSettled | `Promise.allSettled`} with the key distinction that it operates lazily.
      */
-    static allSettled<TValue>(promises: LazyPromise<TValue>[], settings?: LazyPromiseSettings): LazyPromise<PromiseSettledResult<TValue>[]>;
+    static allSettled<TValue>(promises: LazyPromise<TValue>[]): LazyPromise<PromiseSettledResult<TValue>[]>;
     /**
-     * The <i>race<i> method works similarly to <i>{@link Promise.race}</i> with the key distinction that it operates lazily.
+     * The `race` method works similarly to {@link Promise.race | `Promise.race`} with the key distinction that it operates lazily.
      */
-    static race<TValue>(promises: LazyPromise<TValue>[], settings?: LazyPromiseSettings): LazyPromise<TValue>;
+    static race<TValue>(promises: LazyPromise<TValue>[]): LazyPromise<TValue>;
     /**
-     * The <i>any<i> method works similarly to <i>{@link Promise.any}</i> with the key distinction that it operates lazily.
+     * The `any` method works similarly to {@link Promise.any | `Promise.any`} with the key distinction that it operates lazily.
      */
-    static any<TValue>(promises: LazyPromise<TValue>[], settings?: LazyPromiseSettings): LazyPromise<TValue>;
+    static any<TValue>(promises: LazyPromise<TValue>[]): LazyPromise<TValue>;
     /**
-     * The <i>fromCallback</i> is convience method used for wrapping Node js callback functions with a <i>LazyPromise</i>.
+     * The `fromCallback` is convience method used for wrapping Node js callback functions with a `LazyPromise`.
      * @example
      * ```ts
      * import { LazyPromise } from "@daiso-tech/core/async";
@@ -133,160 +97,39 @@ export declare class LazyPromise<TValue> implements PromiseLike<TValue>, ISyncEv
      * console.log(file);
      * ```
      */
-    static fromCallback<TValue>(callback: LazyPromiseCallback<TValue>, settings?: LazyPromiseSettings): LazyPromise<TValue>;
+    static fromCallback<TValue>(callback: LazyPromiseCallback<TValue>): LazyPromise<TValue>;
     private promise;
-    private asyncFn;
-    private readonly settings;
-    private readonly eventBus;
+    private readonly invokable;
     /**
      * @example
      * ```ts
-     * import { LazyPromise } from "@daiso-tech/core/async";
+     * import { LazyPromise, retryMiddleware } from "@daiso-tech/core/async";
      *
      * const promise = new LazyPromise(async () => {
      *   console.log("I am lazy");
-     * });
+     * },
+     *   // You can also pass in one AsyncMiddleware or multiple (as an Array).
+     *   retry()
+     * );
      *
      * // "I am lazy" will only logged when awaited or then method i called.
      * await promise;
      * ```
      *
-     * You can pass sync or async <i>{@link Invokable}</i>.
-     */
-    constructor(invokable: AsyncLazy<TValue>, settings?: LazyPromiseSettings);
-    addListener<TEventClass extends EventClass<AsyncEvents<TValue>>>(event: TEventClass, listener: EventListener<EventInstance<TEventClass>>): void;
-    removeListener<TEventClass extends EventClass<AsyncEvents<TValue>>>(event: TEventClass, listener: EventListener<EventInstance<TEventClass>>): void;
-    private applyRetryTimeout;
-    private applyRetry;
-    private applyTotalTimeout;
-    private applyAbort;
-    private applySettings;
-    /**
-     * The <i>setBackoffPolicy</i> method is used for setting a custom <i>{@link BackoffPolicy}</i>.
-     * ```ts
-     * import { LazyPromise, linearBackoffPolicy } from "@daiso-tech/core/async";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     *
-     * const promise =
-     *   new LazyPromise(async () => {
-     *     console.log("A");
-     *     throw new Error("Error occured!");
-     *   })
-     *   .setRetryAttempts(3)
-     *   .setBackoffPolicy(linearBackoffPolicy())
-     *
-     * // Will log "A" 3 times and then retry error will be thrown.
-     * await promise;
-     * ```
-     */
-    setBackoffPolicy(policy: BackoffPolicy | null): LazyPromise<TValue>;
-    /**
-     * The <i>setRetryAttempts</i> method is used for setting max retry attempts.
-     * @example
-     * ```ts
-     * import { LazyPromise } from "@daiso-tech/core/async";
-     *
-     * const promise =
-     *   new LazyPromise(async () => {
-     *     console.log("A");
-     *     throw new Error("Error occured!");
-     *   })
-     *   .setRetryAttempts(3)
-     *
-     * // Will log "A" 3 times and then retry error will be thrown.
-     * await promise;
-     * ```
+     * You can pass sync or async {@link Invokable | `Invokable`}.
      */
-    setRetryAttempts(attempts: number | null): LazyPromise<TValue>;
+    constructor(invokable: AsyncLazy<TValue>, middlewares?: OneOrMore<AsyncMiddleware<[], TValue>>);
     /**
-     * The <i>setRetryPolicy</i> method is used for setting a custom <i>{@link BackoffPolicy}</i>.
-     * @example
-     * ```ts
-     * import { LazyPromise } from "@daiso-tech/core/async";
-     *
-     * class ErrorA extends Error {}
-     *
-     * const promise =
-     *   new LazyPromise(async () => {
-     *     console.log("A");
-     *     throw new Error("Error occured!");
-     *   })
-     *   .setRetryAttempts(3)
-     *   // Will only retry an error that is instance ErrorA
-     *   .setRetryPolicy(error => error instanceof ErrorA)
-     *
-     * // Will log "A" 1 time and then error will be thrown.
-     * await promise;
-     * ```
-     */
-    setRetryPolicy(policy: RetryPolicy | null): LazyPromise<TValue>;
-    /**
-     * The <i>setRetryTimeout</i> method aborts the each retry if it exceeds the given <i>time</i>.
-     * @example
-     * ```ts
-     * import { LazyPromise } from "@daiso-tech/core/async";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     *
-     * const promise =
-     *   new LazyPromise(async () => {
-     *     await LazyPromise.delay(TimeSpan.fromMinutes(1));
-     *   })
-     *   .setRetryTimeout(TimeSpan.fromSeconds(1));
-     *
-     * // An timeout error will be thrown.
-     * await promise;
-     * ```
-     */
-    setRetryTimeout(time: TimeSpan | null): LazyPromise<TValue>;
-    /**
-     * The <i>setTotalTimeout</i> method aborts the <i>LazyPromise</i> if it exceeds the given <i>time</i> by throwning an error.
-     * @example
-     * ```ts
-     * import { LazyPromise } from "@daiso-tech/core/async";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     *
-     * const promise =
-     *   new LazyPromise(async () => {
-     *     await LazyPromise.delay(TimeSpan.fromMinutes(1));
-     *   })
-     *   .setRetryTimeout(TimeSpan.fromSeconds(1));
-     *
-     * // An timeout error will be thrown.
-     * await promise;
-     * ```
-     */
-    setTotalTimeout(time: TimeSpan | null): LazyPromise<TValue>;
-    /**
-     * The <i>setAbortSignal</i> method aborts the <i>LazyPromise</i> by the passed in <i>abortSignal</i>.
-     * @example
-     * ```ts
-     * import { LazyPromise } from "@daiso-tech/core";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     *
-     * const abortController = new AbortController();
-     * const promise =
-     *   new LazyPromise(async () => {
-     *     await LazyPromise.delay(TimeSpan.fromMinutes(1));
-     *   })
-     *   .setAbortSignal(abortController.signal);
-     *
-     * setTimeout(() => {
-     *   abortController.abort();
-     * }, 1000);
-     *
-     * // An timeout error will be thrown.
-     * await promise;
-     * ```
+     * The `pipe` method returns a new `LazyPromise` instance with the additional `middlewares` applied.
      */
-    setAbortSignal(abortSignal: AbortSignal | null): LazyPromise<TValue>;
+    pipe(middlewares: OneOrMore<AsyncMiddleware<[], TValue>>): LazyPromise<TValue>;
     /**
-     * @throws {AbortAsyncError} {@link AbortAsyncError}
-     * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}
-     * @throws {RetryAsyncError} {@link RetryAsyncError}
+     * The `pipeWhen` method conditionally applies additional `middlewares`, returning a new `LazyPromise` instance only if the specified condition is met.
      */
+    pipeWhen(condition: boolean, middlewares: OneOrMore<AsyncMiddleware<[], TValue>>): LazyPromise<TValue>;
     then<TResult1 = TValue, TResult2 = never>(onfulfilled?: ((value: TValue) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
     /**
-     * The <i>defer</i> method executes the <i>LazyPromise</i> without awaiting it.
+     * The `defer` method executes the `LazyPromise` without awaiting it.
      * @example
      * ```ts
      * import { LazyPromise } from "@daiso-tech/core/async";