@daiso-tech/core 0.31.0 → 0.32.0

package/dist/async/_module-exports.d.ts

@@ -1,3 +1,4 @@
 export * from "../async/backof-policies/_module.js";
 export * from "../async/utilities/_module.js";
 export * from "../async/async.errors.js";
+export * from "../async/async.events.js";

package/dist/async/_module-exports.js

@@ -1,4 +1,5 @@
 export * from "../async/backof-policies/_module.js";
 export * from "../async/utilities/_module.js";
 export * from "../async/async.errors.js";
+export * from "../async/async.events.js";
 //# sourceMappingURL=_module-exports.js.map

package/dist/async/_module-exports.js.map

@@ -1 +1 @@
-{"version":3,"file":"_module-exports.js","sourceRoot":"","sources":["../../src/async/_module-exports.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"_module-exports.js","sourceRoot":"","sources":["../../src/async/_module-exports.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC"}

package/dist/async/async.events.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @module Async
+ */
+import type { AbortAsyncError, RetryAsyncError, TimeoutAsyncError } from "../async/async.errors.js";
+import { BaseEvent } from "../event-bus/contracts/_shared.js";
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Events
+ */
+export declare class FailureAsyncEvent extends BaseEvent<{
+    error: unknown;
+}> {
+}
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Events
+ */
+export declare class SuccessAsyncEvent<TValue> extends BaseEvent<{
+    value: TValue;
+}> {
+}
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Events
+ */
+export declare class FinallyAsyncEvent extends BaseEvent<{}> {
+}
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Events
+ */
+export declare class RetryAttemptAsyncEvent extends BaseEvent<{
+    attempt: number;
+    error: unknown;
+}> {
+}
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Events
+ */
+export declare class RetryTimeoutAsyncEvent extends BaseEvent<{
+    error: TimeoutAsyncError;
+}> {
+}
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Events
+ */
+export declare class RetryFailureAsyncEvent extends BaseEvent<{
+    error: RetryAsyncError;
+}> {
+}
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Events
+ */
+export declare class TotalTimeoutFailureAsyncEvent extends BaseEvent<{
+    error: TimeoutAsyncError;
+}> {
+}
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Events
+ */
+export declare class AbortAsyncEvent extends BaseEvent<{
+    error: AbortAsyncError;
+}> {
+}
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Events
+ */
+export type AsyncEvents<TValue> = FailureAsyncEvent | SuccessAsyncEvent<TValue> | FinallyAsyncEvent | RetryAttemptAsyncEvent | RetryTimeoutAsyncEvent | RetryFailureAsyncEvent | TotalTimeoutFailureAsyncEvent | AbortAsyncEvent;

package/dist/async/async.events.js

@@ -0,0 +1,59 @@
+import { BaseEvent } from "../event-bus/contracts/_shared.js";
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Events
+ */
+export class FailureAsyncEvent extends BaseEvent {
+}
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Events
+ */
+export class SuccessAsyncEvent extends BaseEvent {
+}
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Events
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export class FinallyAsyncEvent extends BaseEvent {
+}
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Events
+ */
+export class RetryAttemptAsyncEvent extends BaseEvent {
+}
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Events
+ */
+export class RetryTimeoutAsyncEvent extends BaseEvent {
+}
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Events
+ */
+export class RetryFailureAsyncEvent extends BaseEvent {
+}
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Events
+ */
+export class TotalTimeoutFailureAsyncEvent extends BaseEvent {
+}
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Events
+ */
+export class AbortAsyncEvent extends BaseEvent {
+}
+//# sourceMappingURL=async.events.js.map

package/dist/async/async.events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.events.js","sourceRoot":"","sources":["../../src/async/async.events.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAE7D;;;;GAIG;AACH,MAAM,OAAO,iBAAkB,SAAQ,SAErC;CAAG;AAEL;;;;GAIG;AACH,MAAM,OAAO,iBAA0B,SAAQ,SAE7C;CAAG;AAEL;;;;GAIG;AACH,mEAAmE;AACnE,MAAM,OAAO,iBAAkB,SAAQ,SAAa;CAAG;AAEvD;;;;GAIG;AACH,MAAM,OAAO,sBAAuB,SAAQ,SAG1C;CAAG;AAEL;;;;GAIG;AACH,MAAM,OAAO,sBAAuB,SAAQ,SAE1C;CAAG;AAEL;;;;GAIG;AACH,MAAM,OAAO,sBAAuB,SAAQ,SAE1C;CAAG;AAEL;;;;GAIG;AACH,MAAM,OAAO,6BAA8B,SAAQ,SAEjD;CAAG;AAEL;;;;GAIG;AACH,MAAM,OAAO,eAAgB,SAAQ,SAEnC;CAAG"}

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

@@ -0,0 +1,15 @@
+/**
+ * @module Async
+ */
+import { type Invokable } from "../../../utilities/_module-exports.js";
+import type { ILazyPromiseListener } from "../../../async/utilities/lazy-promise/lazy-promise-listener.contract.js";
+/**
+ * @internal
+ */
+export declare class LazyPromiseEventBus<TEventMap extends Record<string, unknown>> implements ILazyPromiseListener<TEventMap> {
+    private readonly eventMap;
+    dispatch<TEventName extends keyof TEventMap>(eventName: Extract<TEventName, string>, event: TEventMap[TEventName]): void;
+    addListener<TEventName extends keyof TEventMap>(eventName: Extract<TEventName, string>, listener: Invokable<[event: TEventMap[TEventName]]>): void;
+    removeListener<TEventName extends keyof TEventMap>(eventName: Extract<TEventName, string>, listener: Invokable<[event: TEventMap[TEventName]]>): void;
+    clear(): void;
+}

package/dist/async/utilities/lazy-promise/lazy-promise-event-bus.js

@@ -0,0 +1,50 @@
+/**
+ * @module Async
+ */
+import { callInvokable } from "../../../utilities/_module-exports.js";
+/**
+ * @internal
+ */
+export class LazyPromiseEventBus {
+    eventMap = new Map();
+    dispatch(eventName, event) {
+        if (this.eventMap.size === 0) {
+            return;
+        }
+        const eventListeners = this.eventMap.get(eventName);
+        if (eventListeners === undefined) {
+            return;
+        }
+        if (eventListeners.size === 0) {
+            return;
+        }
+        for (const eventListener of eventListeners) {
+            callInvokable(eventListener, event);
+        }
+    }
+    addListener(eventName, listener) {
+        let eventListeners = this.eventMap.get(eventName);
+        if (eventListeners === undefined) {
+            eventListeners = new Set();
+            this.eventMap.set(eventName, eventListeners);
+        }
+        eventListeners.add(listener);
+    }
+    removeListener(eventName, listener) {
+        const eventListeners = this.eventMap.get(eventName);
+        if (eventListeners === undefined) {
+            return;
+        }
+        eventListeners.delete(listener);
+        if (eventListeners.size === 0) {
+            this.eventMap.delete(eventName);
+        }
+    }
+    clear() {
+        for (const eventListeners of this.eventMap.values()) {
+            eventListeners.clear();
+        }
+        this.eventMap.clear();
+    }
+}
+//# sourceMappingURL=lazy-promise-event-bus.js.map

package/dist/async/utilities/lazy-promise/lazy-promise-event-bus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-promise-event-bus.js","sourceRoot":"","sources":["../../../../src/async/utilities/lazy-promise/lazy-promise-event-bus.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAkB,MAAM,gCAAgC,CAAC;AAG/E;;GAEG;AACH,MAAM,OAAO,mBAAmB;IAGX,QAAQ,GAAG,IAAI,GAAG,EAAwC,CAAC;IAE5E,QAAQ,CACJ,SAAsC,EACtC,KAA4B;QAE5B,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;YAC3B,OAAO;QACX,CAAC;QACD,MAAM,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACpD,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;YAC/B,OAAO;QACX,CAAC;QACD,IAAI,cAAc,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;YAC5B,OAAO;QACX,CAAC;QACD,KAAK,MAAM,aAAa,IAAI,cAAc,EAAE,CAAC;YACzC,aAAa,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;QACxC,CAAC;IACL,CAAC;IAED,WAAW,CACP,SAAsC,EACtC,QAAmD;QAEnD,IAAI,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAClD,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;YAC/B,cAAc,GAAG,IAAI,GAAG,EAAE,CAAC;YAC3B,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;QACjD,CAAC;QACD,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACjC,CAAC;IAED,cAAc,CACV,SAAsC,EACtC,QAAmD;QAEnD,MAAM,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACpD,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;YAC/B,OAAO;QACX,CAAC;QACD,cAAc,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAChC,IAAI,cAAc,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;YAC5B,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QACpC,CAAC;IACL,CAAC;IAED,KAAK;QACD,KAAK,MAAM,cAAc,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;YAClD,cAAc,CAAC,KAAK,EAAE,CAAC;QAC3B,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;IAC1B,CAAC;CACJ"}

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

@@ -0,0 +1,23 @@
+/**
+ * @module Async
+ */
+import { type Invokable } from "../../../utilities/_module-exports.js";
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Utilities
+ */
+export type ILazyPromiseListener<TEventMap extends Record<string, unknown>> = {
+    addListener<TEventName extends keyof TEventMap>(eventName: Extract<TEventName, string>, listener: Invokable<[event: TEventMap[TEventName]]>): void;
+    removeListener<TEventName extends keyof TEventMap>(eventName: Extract<TEventName, string>, listener: Invokable<[event: TEventMap[TEventName]]>): void;
+};
+/**
+ * @internal
+ */
+export declare class LazyPromiseEventBus<TEventMap extends Record<string, unknown>> implements ILazyPromiseListener<TEventMap> {
+    private readonly eventMap;
+    dispatch<TEventName extends keyof TEventMap>(eventName: Extract<TEventName, string>, event: TEventMap[TEventName]): void;
+    addListener<TEventName extends keyof TEventMap>(eventName: Extract<TEventName, string>, listener: Invokable<[event: TEventMap[TEventName]]>): void;
+    removeListener<TEventName extends keyof TEventMap>(eventName: Extract<TEventName, string>, listener: Invokable<[event: TEventMap[TEventName]]>): void;
+    clear(): void;
+}

package/dist/async/utilities/lazy-promise/lazy-promise-listener.contract.js

@@ -0,0 +1,44 @@
+/**
+ * @module Async
+ */
+import { callInvokable } from "../../../utilities/_module-exports.js";
+/**
+ * @internal
+ */
+export class LazyPromiseEventBus {
+    eventMap = new Map();
+    dispatch(eventName, event) {
+        const eventListeners = this.eventMap.get(eventName);
+        if (eventListeners === undefined) {
+            return;
+        }
+        for (const eventListener of eventListeners) {
+            callInvokable(eventListener, event);
+        }
+    }
+    addListener(eventName, listener) {
+        let eventListeners = this.eventMap.get(eventName);
+        if (eventListeners === undefined) {
+            eventListeners = new Set();
+            this.eventMap.set(eventName, eventListeners);
+        }
+        eventListeners.add(listener);
+    }
+    removeListener(eventName, listener) {
+        const eventListeners = this.eventMap.get(eventName);
+        if (eventListeners === undefined) {
+            return;
+        }
+        eventListeners.delete(listener);
+        if (eventListeners.size === 0) {
+            this.eventMap.delete(eventName);
+        }
+    }
+    clear() {
+        for (const eventListeners of this.eventMap.values()) {
+            eventListeners.clear();
+        }
+        this.eventMap.clear();
+    }
+}
+//# sourceMappingURL=lazy-promise-listener.contract.js.map

package/dist/async/utilities/lazy-promise/lazy-promise-listener.contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-promise-listener.contract.js","sourceRoot":"","sources":["../../../../src/async/utilities/lazy-promise/lazy-promise-listener.contract.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAkB,MAAM,gCAAgC,CAAC;AAmB/E;;GAEG;AACH,MAAM,OAAO,mBAAmB;IAGX,QAAQ,GAAG,IAAI,GAAG,EAAwC,CAAC;IAE5E,QAAQ,CACJ,SAAsC,EACtC,KAA4B;QAE5B,MAAM,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACpD,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;YAC/B,OAAO;QACX,CAAC;QACD,KAAK,MAAM,aAAa,IAAI,cAAc,EAAE,CAAC;YACzC,aAAa,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;QACxC,CAAC;IACL,CAAC;IAED,WAAW,CACP,SAAsC,EACtC,QAAmD;QAEnD,IAAI,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAClD,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;YAC/B,cAAc,GAAG,IAAI,GAAG,EAAE,CAAC;YAC3B,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;QACjD,CAAC;QACD,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACjC,CAAC;IAED,cAAc,CACV,SAAsC,EACtC,QAAmD;QAEnD,MAAM,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACpD,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;YAC/B,OAAO;QACX,CAAC;QACD,cAAc,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAChC,IAAI,cAAc,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;YAC5B,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QACpC,CAAC;IACL,CAAC;IAED,KAAK;QACD,KAAK,MAAM,cAAc,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;YAClD,cAAc,CAAC,KAAK,EAAE,CAAC;QAC3B,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;IAC1B,CAAC;CACJ"}

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

@@ -2,70 +2,95 @@
  * @module Async
  */
 import type { BackoffPolicy } from "../../../async/backof-policies/_module.js";
-import type { AsyncLazy, Invokable, InvokableFn, Promisable, TimeSpan } from "../../../utilities/_module-exports.js";
+import type { AsyncLazy, Invokable, InvokableFn, ISyncEventListenable, Promisable, TimeSpan } from "../../../utilities/_module-exports.js";
 import type { RetryPolicy } from "../../../async/utilities/retry/_module.js";
+import { TimeoutAsyncError } from "../../../async/async.errors.js";
+import { RetryAsyncError } from "../../../async/async.errors.js";
+import { AbortAsyncError } from "../../../async/async.errors.js";
+import { type AsyncEvents } from "../../../async/async.events.js";
+import type { EventClass, EventListener, EventInstance } from "../../../event-bus/contracts/event-bus.contract.js";
 /**
  *
  * IMPORT_PATH: ```"@daiso-tech/core/async"```
  * @group Utilities
  */
-export type LazyPromiseOnFinally = () => Promisable<void>;
-/**
- *
- * IMPORT_PATH: ```"@daiso-tech/core/async"```
- * @group Utilities
- */
-export type LazyPromiseOnSuccess<TValue> = (value: TValue) => Promisable<void>;
+export type AsyncEventMap<TValue = unknown> = {
+    failure: {
+        error: unknown;
+    };
+    success: {
+        value: TValue;
+    };
+    finally: undefined;
+    retryAttempt: {
+        attempt: number;
+        error: unknown;
+    };
+    retryTimeoutFailure: {
+        error: TimeoutAsyncError;
+    };
+    retryFailure: {
+        error: RetryAsyncError;
+    };
+    totalTimeoutFailure: {
+        error: TimeoutAsyncError;
+    };
+    abortFailure: {
+        error: AbortAsyncError;
+    };
+};
 /**
  *
  * IMPORT_PATH: ```"@daiso-tech/core/async"```
  * @group Utilities
  */
-export type LazyPromiseOnError = (error: unknown) => Promisable<void>;
+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"```
  * @group Utilities
  */
-export type LazyPromiseCallbacks<TValue = unknown> = {
-    onFinally?: LazyPromiseOnFinally;
-    onSuccess?: LazyPromiseOnSuccess<TValue>;
-    onError?: LazyPromiseOnError;
-};
+export type LazyPromiseResolve<TValue> = InvokableFn<[
+    value: Promisable<TValue>
+], void>;
 /**
  *
  * IMPORT_PATH: ```"@daiso-tech/core/async"```
  * @group Utilities
  */
-export type LazyPromiseSettingsBase = {
-    backoffPolicy?: BackoffPolicy | null;
-    retryAttempts?: number | null;
-    retryPolicy?: RetryPolicy | null;
-    retryTimeout?: TimeSpan | null;
-    totalTimeout?: TimeSpan | null;
-};
+export type LazyPromiseReject = InvokableFn<[error: unknown], void>;
 /**
  *
  * IMPORT_PATH: ```"@daiso-tech/core/async"```
  * @group Utilities
  */
-export type LazyPromiseSettings<TValue = unknown> = LazyPromiseCallbacks<TValue> & LazyPromiseSettingsBase & {
-    abortSignal?: AbortSignal | null;
-};
+export type LazyPromiseCallback<TValue> = InvokableFn<[
+    resolve: LazyPromiseResolve<TValue>,
+    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>retryAttempts</i>
- * - <i>retryPolicy</i>
- * - <i>backoffPolicy</i>
- * - <i>abort</i>
- * - <i>timeout</i>
+ * - <i>setRetryAttempts</i>
+ * - <i>setRetryTimeout</i>
+ * - <i>setRetryPolicy</i>
+ * - <i>setBackoffPolicy</i>
+ * - <i>setTotalTimeout</i>
+ * - <i>setAbortSignal</i>
  *
  * The order in which these methods are called does not affect their methodality. Internally, the following execution order is applied:
- * 1. <i>timeout</i>
- * 2. <i>retryAttempts</i>
- * 3. <i>abort</i>
+ * 1. <i>setRetryTimeout</i>
+ * 2. <i>setRetryAttempts</i>
+ * 3. <i>setTotalTimeout</i>
+ * 4. <i>setAbortSignal</i>
  *
  * This means that combining all methods ensures the <i>retryAttempts</i> method will continue retrying even if the timeout is triggered,
  * while the <i>abort</i> method takes priority to cancel all operations if activated.
@@ -73,9 +98,9 @@ export type LazyPromiseSettings<TValue = unknown> = LazyPromiseCallbacks<TValue>
  * IMPORT_PATH: ```"@daiso-tech/core/async"```
  * @group Utilities
  */
-export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
+export declare class LazyPromise<TValue> implements PromiseLike<TValue>, ISyncEventListenable<AsyncEvents<TValue>> {
     /**
-     * The <i>wrapFn</i> is convience method used for wrapping a sync or async function with a <i>LazyPromise</i>.
+     * The <i>wrapFn</i> is convience method used for wrapping async <i>{@link Invokable}</i> with a <i>LazyPromise</i>.
      * @example
      * ```ts
      * import { LazyPromise } from "@daiso-tech/core/async";
@@ -86,10 +111,10 @@ export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
      *
      * const file = await readFile("none_existing_file.txt")
      *   .setRetryAttempts(4)
-     *   .timeout(TimeSpan.fromMinutes(1));
+     *   .setRetryTimeout(TimeSpan.fromMinutes(1));
      * ```
      */
-    static wrapFn<TArgs extends unknown[], TReturn>(fn: Invokable<TArgs, Promisable<TReturn>>, settings?: LazyPromiseSettings<TReturn>): InvokableFn<TArgs, LazyPromise<TReturn>>;
+    static wrapFn<TArgs extends unknown[], TReturn>(fn: Invokable<TArgs, Promisable<TReturn>>, settings?: LazyPromiseSettings): InvokableFn<TArgs, LazyPromise<TReturn>>;
     /**
      * The <i>delay</i> method creates a <i>{@link LazyPromise}</i> that will be fulfilled after given <i>time</i>.
      *
@@ -103,27 +128,50 @@ export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
      * console.log("a");
      * await LazyPromise.delay(TimeSpan.fromSeconds(2));
      * console.log("b");
+     * ```
      */
     static delay(time: TimeSpan): LazyPromise<void>;
     /**
      * The <i>all<i> method works similarly to <i>{@link Promise.all}</i> with the key distinction that it operates lazily.
      */
-    static all<TValue>(promises: LazyPromise<TValue>[]): LazyPromise<TValue[]>;
+    static all<TValue>(promises: LazyPromise<TValue>[], settings?: LazyPromiseSettings): LazyPromise<TValue[]>;
     /**
      * The <i>allSettled<i> method works similarly to <i>{@link Promise.allSettled}</i> with the key distinction that it operates lazily.
      */
-    static allSettled<TValue>(promises: LazyPromise<TValue>[]): LazyPromise<PromiseSettledResult<TValue>[]>;
+    static allSettled<TValue>(promises: LazyPromise<TValue>[], settings?: LazyPromiseSettings): LazyPromise<PromiseSettledResult<TValue>[]>;
     /**
      * The <i>race<i> method works similarly to <i>{@link Promise.race}</i> with the key distinction that it operates lazily.
      */
-    static race<TValue>(promises: LazyPromise<TValue>[]): LazyPromise<TValue>;
+    static race<TValue>(promises: LazyPromise<TValue>[], settings?: LazyPromiseSettings): LazyPromise<TValue>;
     /**
      * The <i>any<i> method works similarly to <i>{@link Promise.any}</i> with the key distinction that it operates lazily.
      */
-    static any<TValue>(promises: LazyPromise<TValue>[]): LazyPromise<TValue>;
+    static any<TValue>(promises: LazyPromise<TValue>[], settings?: LazyPromiseSettings): LazyPromise<TValue>;
+    /**
+     * The <i>fromCallback</i> is convience method used for wrapping Node js callback functions with a <i>LazyPromise</i>.
+     * @example
+     * ```ts
+     * import { LazyPromise } from "@daiso-tech/core/async";
+     * import { readFile } from "node:fs";
+     *
+     * const lazyPromise = LazyPromise.fromCallback<Buffer>((resolve, reject) => {
+     *   readFile("FILE_PATH", (err, data) => {
+     *     if (err !== null) {
+     *       reject(err);
+     *       return;
+     *     }
+     *     resolve(data);
+     *   });
+     * });
+     * const file = await lazyPromise;
+     * console.log(file);
+     * ```
+     */
+    static fromCallback<TValue>(callback: LazyPromiseCallback<TValue>, settings?: LazyPromiseSettings): LazyPromise<TValue>;
     private promise;
     private asyncFn;
     private readonly settings;
+    private readonly eventBus;
     /**
      * @example
      * ```ts
@@ -135,19 +183,18 @@ export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
      *
      * // "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(asyncFn: AsyncLazy<TValue>, settings?: LazyPromiseSettings<TValue>);
+    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;
-    /**
-     * @throws {AbortAsyncError} {@link AbortAsyncError}
-     * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}
-     * @throws {RetryAsyncError} {@link RetryAsyncError}
-     */
-    then<TResult1 = TValue, TResult2 = never>(onfulfilled?: ((value: TValue) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
     /**
      * The <i>setBackoffPolicy</i> method is used for setting a custom <i>{@link BackoffPolicy}</i>.
      * ```ts
@@ -266,14 +313,17 @@ export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
      * ```
      */
     setAbortSignal(abortSignal: AbortSignal | null): LazyPromise<TValue>;
-    onFinally(cb: LazyPromiseOnFinally): LazyPromise<TValue>;
-    onSuccess(cb: LazyPromiseOnSuccess<TValue>): LazyPromise<TValue>;
-    onError(cb: LazyPromiseOnError): LazyPromise<TValue>;
+    /**
+     * @throws {AbortAsyncError} {@link AbortAsyncError}
+     * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}
+     * @throws {RetryAsyncError} {@link RetryAsyncError}
+     */
+    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.
      * @example
      * ```ts
-     * import { LazyPromise } from "@daiso-tech/core";
+     * import { LazyPromise } from "@daiso-tech/core/async";
      * import { TimeSpan } from "@daiso-tech/core/utilities";
      *
      * const promise =