@daiso-tech/core 0.22.2 → 0.24.0

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

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

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

@@ -0,0 +1,21 @@
+/**
+ * @module Async
+ */
+import { type TimeSpan } from "../../../utilities/_module-exports.js";
+/**
+ * The <i>delay</i> function creates a promise that will be fulfilled after given <i>time</i> and can be aborted by providing <i>abortSignal</i>.
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @example
+ * ```ts
+ * import { delay, TimeSpan } from "@daiso-tech/core";
+ * (async () => {
+ *   console.log("a");
+ *   await delay(TimeSpan.fromSeconds(2));
+ *   console.log("b");
+ * })();
+ */
+export declare function delay(time: TimeSpan, abortSignal?: AbortSignal): Promise<void>;

package/dist/async/utilities/delay/delay.js

@@ -0,0 +1,45 @@
+/**
+ * @module Async
+ */
+import {} from "../../../utilities/_module-exports.js";
+import { 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+AsyncError, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+AbortAsyncError, } from "../../../async/async.errors.js";
+import { abortAndFail } from "../../../async/utilities/abort/_module.js";
+/**
+ * The <i>delay</i> function creates a promise that will be fulfilled after given <i>time</i> and can be aborted by providing <i>abortSignal</i>.
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @example
+ * ```ts
+ * import { delay, TimeSpan } from "@daiso-tech/core";
+ * (async () => {
+ *   console.log("a");
+ *   await delay(TimeSpan.fromSeconds(2));
+ *   console.log("b");
+ * })();
+ */
+export async function delay(time, abortSignal = new AbortController().signal) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let timeoutId = null;
+    try {
+        // eslint-disable-next-line @typescript-eslint/return-await
+        return abortAndFail(() => new Promise((resolve) => {
+            timeoutId = setTimeout(() => {
+                resolve();
+            }, time.toMilliseconds());
+        }), abortSignal);
+    }
+    finally {
+        if (timeoutId === null) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            clearTimeout(timeoutId);
+        }
+    }
+}
+//# sourceMappingURL=delay.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delay.js","sourceRoot":"","sources":["../../../../src/async/utilities/delay/delay.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAiB,MAAM,gCAAgC,CAAC;AAC/D,OAAO;AACH,6DAA6D;AAC7D,UAAU;AACV,6DAA6D;AAC7D,eAAe,GAClB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAElE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,KAAK,UAAU,KAAK,CACvB,IAAc,EACd,cAA2B,IAAI,eAAe,EAAE,CAAC,MAAM;IAEvD,8DAA8D;IAC9D,IAAI,SAAS,GAAQ,IAAI,CAAC;IAC1B,IAAI,CAAC;QACD,2DAA2D;QAC3D,OAAO,YAAY,CACf,GAAG,EAAE,CACD,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YAC1B,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE;gBACxB,OAAO,EAAE,CAAC;YACd,CAAC,EAAE,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;QAC9B,CAAC,CAAC,EACN,WAAW,CACd,CAAC;IACN,CAAC;YAAS,CAAC;QACP,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;YACrB,iEAAiE;YACjE,YAAY,CAAC,SAAS,CAAC,CAAC;QAC5B,CAAC;IACL,CAAC;AACL,CAAC"}

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

@@ -0,0 +1 @@
+export * from "../../../async/utilities/lazy-promise/lazy-promise.js";

package/dist/async/utilities/lazy-promise/_module.js

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

package/dist/async/utilities/lazy-promise/_module.js.map

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

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

@@ -0,0 +1,214 @@
+/**
+ * @module Async
+ */
+import type { BackoffPolicy } from "../../../async/backof-policies/_module.js";
+import type { TimeSpan } from "../../../utilities/_module-exports.js";
+import type { RetryPolicy } from "../../../async/utilities/retry/_module.js";
+import { type Func } from "../../../utilities/_module-exports.js";
+/**
+ * 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>
+ *
+ * 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>
+ *
+ * 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.
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Utilities
+ */
+export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
+    /**
+     * The <i>wrapFn</i> is convience method used for wrapping a async method with a <i>LazyPromise</i>.
+     * @example
+     * ```ts
+     * import { LazyPromise, TimeSpan } from "@daiso-tech/core";
+     * import { readFile as readFileNodeJs } from "node:fs/promises";
+     *
+     * const readFile = LazyPromise.wrapFn(readFileNodeJs, {
+     *   retryAttempts: 3
+     * });
+     *
+     * (async () => {
+     *   await readFile("none_existing_file.txt").timeout(TimeSpan.fromMinutes(1));
+     * })();
+     * ```
+     */
+    static wrapFn<TParameters extends unknown[], TReturn>(fn: Func<TParameters, PromiseLike<TReturn>>): Func<TParameters, LazyPromise<TReturn>>;
+    /**
+     * 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[]>;
+    /**
+     * 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>[]>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    private promise;
+    private attempts;
+    private backoffPolicy_;
+    private retryPolicy_;
+    private abortSignal;
+    private time;
+    private asyncFn;
+    /**
+     * @example
+     * ```ts
+     * import { LazyPromise } from "@daiso-tech/core";
+     *
+     * (async () => {
+     *   const promise = new LazyPromise(async () => {
+     *     console.log("I am lazy");
+     *   });
+     *   // "I am lazy" will only logged when awaited or then method i called.
+     *   await promise;
+     * })();
+     */
+    constructor(asyncFn: () => PromiseLike<TValue>);
+    private applyTimeout;
+    private applyRetry;
+    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>setRetryAttempts</i> method is used for setting max retry attempts.
+     * @example
+     * ```ts
+     * import { LazyPromise } from "@daiso-tech/core";
+     *
+     * const promise =
+     *   new LazyPromise(async () => {
+     *     console.log("A");
+     *     throw new Error("Error occured!");
+     *   })
+     *   .setRetryAttempts(3)
+     * (async () => {
+     *   // Will log "A" 3 times and then retry error will be thrown.
+     *   await promise;
+     * })();
+     * ```
+     */
+    setRetryAttempts(attempts: number | null): this;
+    /**
+     * The <i>setBackoffPolicy</i> method is used for setting a custom <i>{@link BackoffPolicy}</i>.
+     * @example
+     * ```ts
+     * import { LazyPromise, linearBackoffPolicy } from "@daiso-tech/core";
+     *
+     * const promise =
+     *   new LazyPromise(async () => {
+     *     console.log("A");
+     *     throw new Error("Error occured!");
+     *   })
+     *   .setRetryAttempts(3)
+     *   .setBackoffPolicy(linearBackoffPolicy())
+     * (async () => {
+     *   // Will log "A" 3 times and then retry error will be thrown.
+     *   await promise;
+     * })();
+     * ```
+     */
+    setBackoffPolicy(policy: BackoffPolicy | null): this;
+    /**
+     * The <i>setRetryPolicy</i> method is used for setting a custom <i>{@link BackoffPolicy}</i>.
+     * @example
+     * ```ts
+     * import { LazyPromise } from "@daiso-tech/core";
+     *
+     * 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)
+     * (async () => {
+     *   // Will log "A" 1 time and then error will be thrown.
+     *   await promise;
+     * })();
+     * ```
+     */
+    setRetryPolicy(policy: RetryPolicy | null): this;
+    /**
+     * The <i>setTimeout</i> method aborts the <i>LazyPromise</i> if it exceeds the given <i>time</i> by throwning an error.
+     * @example
+     * ```ts
+     * import { LazyPromise, delay, TimeSpan } from "@daiso-tech/core";
+     *
+     * const promise =
+     *   new LazyPromise(async () => {
+     *     await delay(TimeSpan.fromMinutes(1));
+     *   })
+     *   .setTimeout(TimeSpan.fromSeconds(1));
+     * (async () => {
+     *   // An timeout error will be thrown.
+     *   await promise;
+     * })();
+     * ```
+     */
+    setTimeout(time: TimeSpan | null): this;
+    /**
+     * The <i>setAbortSignal</i> method aborts the <i>LazyPromise</i> by the passed in <i>abortSignal</i>.
+     * @example
+     * ```ts
+     * import { LazyPromise, delay, TimeSpan } from "@daiso-tech/core";
+     *
+     * const abortController = new AbortController();
+     * const promise =
+     *   new LazyPromise(async () => {
+     *     await delay(TimeSpan.fromMinutes(1));
+     *   })
+     *   .setAbortSignal(abortController.signal);
+     * (async () => {
+     *   setTimeout(() => {
+     *     abortController.abort();
+     *   }, 1000);
+     *   // An timeout error will be thrown.
+     *   await promise;
+     * })();
+     * ```
+     */
+    setAbortSignal(abortSignal: AbortSignal | null): this;
+    /**
+     * The <i>defer</i> method executes the <i>LazyPromise</i> without awaiting it.
+     * @example
+     * ```ts
+     * import { LazyPromise, delay, TimeSpan } from "@daiso-tech/core";
+     *
+     * const promise =
+     *   new LazyPromise(async () => {
+     *     await delay(TimeSpan.fromSeconds(1));
+     *     // Will be loged after one second
+     *     console.log("Done !");
+     *   });
+     * promise.defer();
+     * // Will be logged immediately
+     * console.log("Hello");
+     * ```
+     */
+    defer(): void;
+}

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

@@ -0,0 +1,301 @@
+/**
+ * @module Async
+ */
+import { retryOrFail } from "../../../async/utilities/retry/_module.js";
+import { timeoutAndFail } from "../../../async/utilities/timeout/_module.js";
+import { abortAndFail } from "../../../async/utilities/abort/_module.js";
+import { 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+AbortAsyncError, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+TimeoutAsyncError, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+RetryAsyncError, } from "../../../async/async.errors.js";
+import { simplifyAsyncLazyable, } from "../../../utilities/_module-exports.js";
+/**
+ * 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>
+ *
+ * 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>
+ *
+ * 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.
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Utilities
+ */
+export class LazyPromise {
+    /**
+     * The <i>wrapFn</i> is convience method used for wrapping a async method with a <i>LazyPromise</i>.
+     * @example
+     * ```ts
+     * import { LazyPromise, TimeSpan } from "@daiso-tech/core";
+     * import { readFile as readFileNodeJs } from "node:fs/promises";
+     *
+     * const readFile = LazyPromise.wrapFn(readFileNodeJs, {
+     *   retryAttempts: 3
+     * });
+     *
+     * (async () => {
+     *   await readFile("none_existing_file.txt").timeout(TimeSpan.fromMinutes(1));
+     * })();
+     * ```
+     */
+    static wrapFn(fn) {
+        return (...parameters) => new LazyPromise(() => fn(...parameters));
+    }
+    /**
+     * The <i>all<i> method works similarly to <i>{@link Promise.all}</i> with the key distinction that it operates lazily.
+     */
+    static all(promises) {
+        return new LazyPromise(async () => Promise.all(promises));
+    }
+    /**
+     * The <i>allSettled<i> method works similarly to <i>{@link Promise.allSettled}</i> with the key distinction that it operates lazily.
+     */
+    static allSettled(promises) {
+        return new LazyPromise(async () => Promise.allSettled(promises));
+    }
+    /**
+     * The <i>race<i> method works similarly to <i>{@link Promise.race}</i> with the key distinction that it operates lazily.
+     */
+    static race(promises) {
+        return new LazyPromise(async () => Promise.race(promises));
+    }
+    /**
+     * The <i>any<i> method works similarly to <i>{@link Promise.any}</i> with the key distinction that it operates lazily.
+     */
+    static any(promises) {
+        return new LazyPromise(async () => Promise.any(promises));
+    }
+    promise = null;
+    attempts = null;
+    backoffPolicy_ = null;
+    retryPolicy_ = null;
+    abortSignal = null;
+    time = null;
+    asyncFn;
+    /**
+     * @example
+     * ```ts
+     * import { LazyPromise } from "@daiso-tech/core";
+     *
+     * (async () => {
+     *   const promise = new LazyPromise(async () => {
+     *     console.log("I am lazy");
+     *   });
+     *   // "I am lazy" will only logged when awaited or then method i called.
+     *   await promise;
+     * })();
+     */
+    constructor(asyncFn) {
+        this.asyncFn = async () => simplifyAsyncLazyable(asyncFn);
+    }
+    applyTimeout() {
+        if (this.time !== null) {
+            const oldAsyncFn = this.asyncFn;
+            const newAsyncFn = () => {
+                if (this.time === null) {
+                    throw new Error(`LazyPromise["time"] field is null`);
+                }
+                return timeoutAndFail(oldAsyncFn, this.time);
+            };
+            this.asyncFn = newAsyncFn;
+        }
+    }
+    applyRetry() {
+        if (this.attempts !== null) {
+            const oldAsyncFn = this.asyncFn;
+            const newAsyncFn = () => {
+                if (this.attempts === null) {
+                    throw new Error(`LazyPromise["attempts"] field is null`);
+                }
+                return retryOrFail(oldAsyncFn, {
+                    backoffPolicy: this.backoffPolicy_ ?? undefined,
+                    retryPolicy: this.retryPolicy_ ?? undefined,
+                    maxAttempts: this.attempts,
+                });
+            };
+            this.asyncFn = newAsyncFn;
+        }
+    }
+    applyAbort() {
+        if (this.abortSignal !== null) {
+            const oldAsyncFn = this.asyncFn;
+            const newAsyncFn = () => {
+                if (this.abortSignal === null) {
+                    throw new Error(`LazyPromise["abortSignal"] field is null`);
+                }
+                return abortAndFail(oldAsyncFn, this.abortSignal);
+            };
+            this.asyncFn = newAsyncFn;
+        }
+    }
+    applySettings() {
+        this.applyTimeout();
+        this.applyRetry();
+        this.applyAbort();
+    }
+    /**
+     * @throws {AbortAsyncError} {@link AbortAsyncError}
+     * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}
+     * @throws {RetryAsyncError} {@link RetryAsyncError}
+     */
+    then(onfulfilled, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    onrejected) {
+        this.applySettings();
+        if (this.promise === null) {
+            this.promise = this.asyncFn();
+        }
+        // eslint-disable-next-line @typescript-eslint/use-unknown-in-catch-callback-variable
+        return this.promise.then(onfulfilled, onrejected);
+    }
+    /**
+     * The <i>setRetryAttempts</i> method is used for setting max retry attempts.
+     * @example
+     * ```ts
+     * import { LazyPromise } from "@daiso-tech/core";
+     *
+     * const promise =
+     *   new LazyPromise(async () => {
+     *     console.log("A");
+     *     throw new Error("Error occured!");
+     *   })
+     *   .setRetryAttempts(3)
+     * (async () => {
+     *   // Will log "A" 3 times and then retry error will be thrown.
+     *   await promise;
+     * })();
+     * ```
+     */
+    setRetryAttempts(attempts) {
+        this.attempts = attempts;
+        return this;
+    }
+    /**
+     * The <i>setBackoffPolicy</i> method is used for setting a custom <i>{@link BackoffPolicy}</i>.
+     * @example
+     * ```ts
+     * import { LazyPromise, linearBackoffPolicy } from "@daiso-tech/core";
+     *
+     * const promise =
+     *   new LazyPromise(async () => {
+     *     console.log("A");
+     *     throw new Error("Error occured!");
+     *   })
+     *   .setRetryAttempts(3)
+     *   .setBackoffPolicy(linearBackoffPolicy())
+     * (async () => {
+     *   // Will log "A" 3 times and then retry error will be thrown.
+     *   await promise;
+     * })();
+     * ```
+     */
+    setBackoffPolicy(policy) {
+        this.backoffPolicy_ = policy;
+        return this;
+    }
+    /**
+     * The <i>setRetryPolicy</i> method is used for setting a custom <i>{@link BackoffPolicy}</i>.
+     * @example
+     * ```ts
+     * import { LazyPromise } from "@daiso-tech/core";
+     *
+     * 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)
+     * (async () => {
+     *   // Will log "A" 1 time and then error will be thrown.
+     *   await promise;
+     * })();
+     * ```
+     */
+    setRetryPolicy(policy) {
+        this.retryPolicy_ = policy;
+        return this;
+    }
+    /**
+     * The <i>setTimeout</i> method aborts the <i>LazyPromise</i> if it exceeds the given <i>time</i> by throwning an error.
+     * @example
+     * ```ts
+     * import { LazyPromise, delay, TimeSpan } from "@daiso-tech/core";
+     *
+     * const promise =
+     *   new LazyPromise(async () => {
+     *     await delay(TimeSpan.fromMinutes(1));
+     *   })
+     *   .setTimeout(TimeSpan.fromSeconds(1));
+     * (async () => {
+     *   // An timeout error will be thrown.
+     *   await promise;
+     * })();
+     * ```
+     */
+    setTimeout(time) {
+        this.time = time;
+        return this;
+    }
+    /**
+     * The <i>setAbortSignal</i> method aborts the <i>LazyPromise</i> by the passed in <i>abortSignal</i>.
+     * @example
+     * ```ts
+     * import { LazyPromise, delay, TimeSpan } from "@daiso-tech/core";
+     *
+     * const abortController = new AbortController();
+     * const promise =
+     *   new LazyPromise(async () => {
+     *     await delay(TimeSpan.fromMinutes(1));
+     *   })
+     *   .setAbortSignal(abortController.signal);
+     * (async () => {
+     *   setTimeout(() => {
+     *     abortController.abort();
+     *   }, 1000);
+     *   // An timeout error will be thrown.
+     *   await promise;
+     * })();
+     * ```
+     */
+    setAbortSignal(abortSignal) {
+        this.abortSignal = abortSignal;
+        return this;
+    }
+    /**
+     * The <i>defer</i> method executes the <i>LazyPromise</i> without awaiting it.
+     * @example
+     * ```ts
+     * import { LazyPromise, delay, TimeSpan } from "@daiso-tech/core";
+     *
+     * const promise =
+     *   new LazyPromise(async () => {
+     *     await delay(TimeSpan.fromSeconds(1));
+     *     // Will be loged after one second
+     *     console.log("Done !");
+     *   });
+     * promise.defer();
+     * // Will be logged immediately
+     * console.log("Hello");
+     * ```
+     */
+    defer() {
+        this.then();
+    }
+}
+//# sourceMappingURL=lazy-promise.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-promise.js","sourceRoot":"","sources":["../../../../src/async/utilities/lazy-promise/lazy-promise.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,2 @@
+export * from "../../../async/utilities/retry/retry-or-fail.js";
+export * from "../../../async/utilities/retry/retry.js";

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

@@ -0,0 +1,3 @@
+export * from "../../../async/utilities/retry/retry-or-fail.js";
+export * from "../../../async/utilities/retry/retry.js";
+//# sourceMappingURL=_module.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../src/async/utilities/retry/_module.ts"],"names":[],"mappings":"AAAA,cAAc,0CAA0C,CAAC;AACzD,cAAc,kCAAkC,CAAC"}

package/dist/async/utilities/retry/retry-or-fail.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @module Async
+ */
+import type { BackoffPolicy } from "../../../async/backof-policies/_module.js";
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Utilities
+ */
+export type RetryPolicy = (error: unknown) => boolean;
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/async"```
+ * @group Utilities
+ */
+export type RetrySettings = {
+    /**
+     * @default {4}
+     */
+    maxAttempts?: number;
+    backoffPolicy?: BackoffPolicy;
+    retryPolicy?: RetryPolicy;
+};
+/**
+ * @internal
+ */
+export declare function retryOrFail<TValue = void>(asyncFn: () => PromiseLike<TValue>, settings?: RetrySettings): Promise<TValue>;