@daiso-tech/core 0.6.0 → 0.7.0

package/dist/types/storage/implementations/storage/storage.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @module Storage
+ */
+import { type IStorageAdapter } from "../../../storage/contracts/_module";
+import { type StorageValue, type IStorage } from "../../../storage/contracts/_module";
+import { type AsyncLazyable, type GetOrAddValue } from "../../../_shared/types";
+import type { Validator } from "../../../utilities/_module";
+import { LazyPromise } from "../../../utilities/_module";
+export type StorageSettings<TType> = {
+    namespace?: string;
+    validator?: Validator<TType>;
+};
+export declare class Storage<TType = unknown> implements IStorage<TType> {
+    private readonly storageAdapter;
+    private readonly namespaceStorageAdapter;
+    private readonly settings;
+    constructor(storageAdapter: IStorageAdapter<any>, { namespace, validator, }?: StorageSettings<TType>);
+    namespace(name: string): IStorage<TType>;
+    exists(key: string): LazyPromise<boolean>;
+    existsMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
+    missing(key: string): LazyPromise<boolean>;
+    missingMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
+    get(key: string): LazyPromise<TType | null>;
+    getMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, TType | null>>;
+    getOr(key: string, defaultValue: AsyncLazyable<TType>): LazyPromise<TType>;
+    getOrMany<TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TType>>): LazyPromise<Record<TKeys, TType>>;
+    getOrFail(key: string): LazyPromise<TType>;
+    add(key: string, value: StorageValue<TType>): LazyPromise<boolean>;
+    addMany<TKeys extends string>(values: Record<TKeys, StorageValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
+    update(key: string, value: TType): LazyPromise<boolean>;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): LazyPromise<Record<TKeys, boolean>>;
+    put(key: string, value: StorageValue<TType>): LazyPromise<boolean>;
+    putMany<TKeys extends string>(values: Record<TKeys, StorageValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
+    remove(key: string): LazyPromise<boolean>;
+    removeMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
+    getAndRemove(key: string): LazyPromise<TType | null>;
+    getOrAdd(key: string, valueToAdd: AsyncLazyable<StorageValue<GetOrAddValue<TType>>>): LazyPromise<TType>;
+    increment(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
+    decrement(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
+    clear(): LazyPromise<void>;
+}

package/dist/types/storage/implementations/storage/with-namespace-storage-adapter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @module Storage
+ */
+import { type IStorageAdapter } from "../../../storage/contracts/_module";
+/**
+ * @internal
+ */
+export declare class WithNamespaceStorageAdapter<TType> implements Required<Omit<IStorageAdapter<TType>, "clear">> {
+    private readonly storageAdapter;
+    private readonly namespace;
+    constructor(storageAdapter: IStorageAdapter<TType>, namespace: string);
+    private withNamespace;
+    private withNamespaceArray;
+    private withNamespaceObject;
+    private withoutNamespace;
+    private withoutNamespaceObject;
+    getMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TType | null>>;
+    addMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    putMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    increment(key: string, value: number): Promise<boolean>;
+    decrement(key: string, value: number): Promise<boolean>;
+    clear(): Promise<void>;
+}

package/dist/types/storage/implementations/storage/with-validation-storage-adapter.d.ts

@@ -0,0 +1,19 @@
+import type { Validator } from "../../../utilities/_module";
+import type { IStorageAdapter } from "../../../storage/contracts/_module";
+/**
+ * @internal
+ */
+export declare class WithValidationStorageAdapter<TType> implements IStorageAdapter<TType> {
+    private readonly storageAdapter;
+    private readonly validator;
+    constructor(storageAdapter: IStorageAdapter<TType>, validator: Validator<TType>);
+    private validateOutput;
+    private validateInput;
+    getMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TType | null>>;
+    addMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    putMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}

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

@@ -1 +1,5 @@
+export * from "../utilities/_module";
+export * from "../utilities/async/_module";
+export * from "../utilities/async-iterable/_module";
 export * from "../utilities/time-span/_module";
+export * from "../utilities/validation/_module";

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

@@ -0,0 +1,7 @@
+export * from "../../utilities/async/_shared";
+export * from "../../utilities/async/abortable/_module";
+export * from "../../utilities/async/backof-policies/_module";
+export * from "../../utilities/async/delay/_module";
+export * from "../../utilities/async/lazy-promise/_module";
+export * from "../../utilities/async/retry/_module";
+export * from "../../utilities/async/timeout/_module";

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

@@ -0,0 +1 @@
+export * from "../../../utilities/async/abortable/abortable";

package/dist/types/utilities/async/abortable/abortable.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @module Async
+ */
+import { LazyPromise } from "../../../utilities/async/lazy-promise/_module";
+/**
+ * The <i>abortable</i> function makes a <i>{@link PromiseLike}</i> object abortable.
+ * @group Promise utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @example
+ * ```ts
+ * import { abortable } from "@daiso-tech/core"
+ *
+ * let a = 0;
+ * const abortController = new AbortController();
+ * const fn = async () => {
+ *  a = 1;
+ *  abortController.abort("My message")
+ *  await new Promise<void>(resolve => {
+ *    setTimeout(() => {
+ *      resolve()
+ *    }, 0)
+ *  })
+ *  a = 2;
+ * }
+ * const promise = abortable(fn, abortController.signal);
+ * (async () => {
+ *  try {
+ *    // An error will be thrown
+ *    await promise;
+ *  }
+ *  finally {
+ *    // Will be 1
+ *    console.log(a);
+ *  }
+ * })();
+ * ```
+ */
+export declare function abortable<TValue>(asyncFn: () => PromiseLike<TValue>, abortSignal: AbortSignal): LazyPromise<TValue>;

package/dist/types/utilities/async/backof-policies/_module.d.ts

@@ -0,0 +1,5 @@
+export { type BackoffPolicy } from "../../../utilities/async/backof-policies/_shared";
+export * from "../../../utilities/async/backof-policies/constant-backoff-policy/_module";
+export * from "../../../utilities/async/backof-policies/exponential-backoff-policy/_module";
+export * from "../../../utilities/async/backof-policies/linear-backoff-policy/_module";
+export * from "../../../utilities/async/backof-policies/polynomial-backoff-policy/_module";

package/dist/types/utilities/async/backof-policies/constant-backoff-policy/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../utilities/async/backof-policies/constant-backoff-policy/constant-backoff-policy";

package/dist/types/utilities/async/backof-policies/constant-backoff-policy/constant-backoff-policy.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @module Async
+ */
+import { TimeSpan } from "../../../../utilities/_module";
+import { type BackoffPolicy } from "../../../../utilities/async/backof-policies/_shared";
+/**
+ * @group Backoff policies
+ */
+export type ConstantBackoffPolicySettings = {
+    /**
+     * @default 1000 milliseconds
+     */
+    delay?: TimeSpan;
+    /**
+     * @default {0.5}
+     */
+    jitter?: number;
+    /**
+     * Used only for testing
+     * @internal
+     */
+    _mathRandom?: () => number;
+};
+/**
+ * Constant backoff policy with jitter
+ * @group Backoff policies
+ */
+export declare function constantBackoffPolicy(settings?: ConstantBackoffPolicySettings | ((error: unknown) => ConstantBackoffPolicySettings)): BackoffPolicy;

package/dist/types/utilities/async/backof-policies/exponential-backoff-policy/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../utilities/async/backof-policies/exponential-backoff-policy/exponential-backoff-policy";

package/dist/types/utilities/async/backof-policies/exponential-backoff-policy/exponential-backoff-policy.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @module Async
+ */
+import { TimeSpan } from "../../../../utilities/_module";
+import type { BackoffPolicy } from "../../../../utilities/async/backof-policies/_shared";
+/**
+ * @group Backoff policies
+ */
+export type ExponentialBackoffPolicySettings = {
+    /**
+     * @default 60_000 milliseconds
+     */
+    maxDelay?: TimeSpan;
+    /**
+     * @default 1_000 milliseconds
+     */
+    minDelay?: TimeSpan;
+    /**
+     * @default {2}
+     */
+    multiplier?: number;
+    /**
+     * @default {0.5}
+     */
+    jitter?: number;
+    /**
+     * Used only for testing
+     * @internal
+     */
+    _mathRandom?: () => number;
+};
+/**
+ * Exponential backoff policy with jitter
+ * @group Backoff policies
+ */
+export declare function exponentialBackoffPolicy(settings?: ExponentialBackoffPolicySettings | ((error: unknown) => ExponentialBackoffPolicySettings)): BackoffPolicy;

package/dist/types/utilities/async/backof-policies/linear-backoff-policy/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../utilities/async/backof-policies/linear-backoff-policy/linear-backoff-policy";

package/dist/types/utilities/async/backof-policies/linear-backoff-policy/linear-backoff-policy.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @module Async
+ */
+import { TimeSpan } from "../../../../utilities/_module";
+import type { BackoffPolicy } from "../../../../utilities/async/backof-policies/_shared";
+/**
+ * @group Backoff policies
+ */
+export type LinearBackoffPolicySettings = {
+    /**
+     * @default 6000 milliseconds
+     */
+    maxDelay?: TimeSpan;
+    /**
+     * @default 1_000 milliseconds
+     */
+    minDelay?: TimeSpan;
+    /**
+     * @default {0.5}
+     */
+    jitter?: number;
+    /**
+     * Used only for testing
+     * @internal
+     */
+    _mathRandom?: () => number;
+};
+/**
+ * Linear backoff policy with jitter
+ * @group Backoff policies
+ */
+export declare function linearBackoffPolicy(settings?: LinearBackoffPolicySettings | ((error: unknown) => LinearBackoffPolicySettings)): BackoffPolicy;

package/dist/types/utilities/async/backof-policies/polynomial-backoff-policy/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../utilities/async/backof-policies/polynomial-backoff-policy/polynomial-backoff-policy";

package/dist/types/utilities/async/backof-policies/polynomial-backoff-policy/polynomial-backoff-policy.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @module Async
+ */
+import { TimeSpan } from "../../../../utilities/_module";
+import type { BackoffPolicy } from "../../../../utilities/async/backof-policies/_shared";
+/**
+ * @group Backoff policies
+ */
+export type PolynomialBackoffPolicySettings = {
+    /**
+     * @default 60_000 milliseconds
+     */
+    maxDelay?: TimeSpan;
+    /**
+     * @default 1_000 milliseconds
+     */
+    minDelay?: TimeSpan;
+    /**
+     * @default {2}
+     */
+    degree?: number;
+    /**
+     * @default {0.5}
+     */
+    jitter?: number;
+    /**
+     * Used only for testing
+     * @internal
+     */
+    _mathRandom?: () => number;
+};
+/**
+ * Polynomial backoff policy with jitter
+ * @group Backoff policies
+ */
+export declare function polynomialBackoffPolicy(settings?: PolynomialBackoffPolicySettings | ((error: unknown) => PolynomialBackoffPolicySettings)): BackoffPolicy;

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

@@ -0,0 +1 @@
+export * from "../../../utilities/async/delay/delay";

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

@@ -0,0 +1,38 @@
+/**
+ * @module Async
+ */
+import type { TimeSpan } from "../../../utilities/_module";
+import { LazyPromise } from "../../../utilities/async/lazy-promise/_module";
+/**
+ * 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>.
+ * @group Promise 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");
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { delay, TimeSpan } from "@daiso-tech/core";
+ *
+ * const abortController = new AbortController();
+ * setTimeout(() => {
+ *  abortController.abort("My abort error");
+ * }, TimeSpan.fromSeconds(1).toMilliseconds());
+ * const promise = delay(TimeSpan.fromSeconds(2), abortController.signal);
+ *
+ * (async () => {
+ *   console.log("a");
+ *   // Will throw AbortAsyncError
+ *   await promise;
+ *   console.log("b");
+ * })();
+ * ```
+ */
+export declare function delay(time: TimeSpan, abortSignal?: AbortSignal): LazyPromise<void>;

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

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

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

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

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

@@ -0,0 +1,86 @@
+/**
+ * @module Async
+ */
+import type { BackoffPolicy } from "../../../utilities/async/backof-policies/_module";
+import { LazyPromise } from "../../../utilities/async/lazy-promise/_module";
+import { TimeSpan } from "../../../utilities/_module";
+export type RetryPolicy = (error: unknown) => boolean;
+/**
+ * @group Promise utilities
+ */
+export type RetrySettings = {
+    /**
+     * @default {4}
+     */
+    maxAttempts?: number;
+    backoffPolicy?: BackoffPolicy;
+    retryPolicy?: RetryPolicy;
+    /**
+     * @default 60_000 milliseconds
+     */
+    retryTimeout?: TimeSpan;
+    abortSignal?: AbortSignal;
+};
+/**
+ * The <i>retry</i> function will retry a async function if it throws an error until given <i>settings.maxAttempts</i>.
+ * You can add timeout for each retry by passing <i>settings.retryTimeout</i> and <i>settings.abortSignal</i> for aborting it on your own.
+ * You can also customize the retry policy by passing <i>settings.retryPolicy</i> and custom backof policy by passing <i>settings.backoffPolicy</i>.
+ * @group Promise utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}
+ * @throws {RetryAsyncError} {@link RetryAsyncError}
+ * @example
+ * ```ts
+ * import { retry, TimeSpan, exponentialBackoffPolicy } from "@daiso-tech/core";
+ *
+ * (async () => {
+ *   // Will throw RetryAsyncError after failing 4:th attempt
+ *   await retry(async () => {
+ *     throw new Error("My error mesasge");
+ *   }, {
+ *     // You can choose the max retry attempts
+ *     maxAttempts: 4,
+ *     // You can provide a custom backoff policy
+ *     backoffPolicy: exponentialBackoffPolicy(),
+ *     // You can choose what error to retry, this function will retry all errors thrown
+ *     retryPolicy: () => true,
+ *     // You can provide a timeout for each retry
+ *     retryTimeout: TimeSpan.fromMilliseconds(60_000),
+ *   });
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { retry, TimeSpan } from "@daiso-tech/core";
+ *
+ * (async () => {
+ *   const abortController = new AbortController();
+ *   abortController.abort("My abort message");
+ *
+ *   // Will be aborted by throwing AbortAsyncError
+ *   await retry(async () => {
+ *     throw new Error("My error message");
+ *   }, {
+ *     abortSignal: abortController.signal
+ *   });
+ * })();
+ * ```
+ * @example with custom retry policy
+ * ```ts
+ * import { retry, TimeSpan } from "@daiso-tech/core";
+ *
+ * class ErrorA extends Error {};
+ * class ErrorB extends Error {};
+ *
+ * (async () => {
+ *   // Will not retry and ErrorB will be thrown
+ *   await retry(async () => {
+ *     throw new ErrorB("My error message");
+ *   }, {
+ *     retryPolicy: error => error instanceof ErrorA
+ *   });
+ * })();
+ * ```
+ */
+export declare function retry<TValue = void>(asyncFn: () => PromiseLike<TValue>, settings?: RetrySettings): LazyPromise<TValue>;

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

@@ -0,0 +1 @@
+export * from "../../../utilities/async/timeout/timeout";

package/dist/types/utilities/async/timeout/timeout.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @module Async
+ */
+import { LazyPromise } from "../../../utilities/async/lazy-promise/_module";
+import type { TimeSpan } from "../../../utilities/_module";
+/**
+ * The <i>timeout</i> function makes a <i>{@link PromiseLike}</i> object abort after a given <i>time</i> and you can also abort it on your own by passing <i>abortSignal</i>.
+ * @group Promise utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}
+ * @example
+ * ```ts
+ * import { timeout, delay, TimeSpan } from "@daiso-tech/core";
+ *
+ * (async () => {
+ *   // Will throw an AbortAsyncError
+ *   await timeout(async () => {
+ *     await delay(TimeSpan.fromSeconds(10));
+ *   }, TimeSpan.fromSeconds(5));
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { timeout, delay, TimeSpan } from "@daiso-tech/core";
+ *
+ * const abortController = new AbortController();
+ * setTimeout(() => {
+ *   abortController.abort("My abort error");
+ * }, TimeSpan.fromSeconds(1));
+ *
+ * (async () => {
+ *   // Will abort after 1 second by throwing AbortAsyncError
+ *   await timeout(async () => {
+ *     await delay(TimeSpan.fromSeconds(10));
+ *   }, TimeSpan.fromSeconds(5), abortController.signal);
+ * })();
+ * ```
+ */
+export declare function timeout<TValue>(asyncFn: () => PromiseLike<TValue>, time: TimeSpan, abortSignal?: AbortSignal): LazyPromise<TValue>;

package/dist/types/utilities/async-iterable/_module.d.ts

@@ -0,0 +1,4 @@
+export * from "../../utilities/async-iterable/abortable-iterable/_module";
+export * from "../../utilities/async-iterable/delay-iterable/_module";
+export { retryIterable as unstable_retryIterable } from "../../utilities/async-iterable/retry-iterable/_module";
+export * from "../../utilities/async-iterable/timeout-iterable/_module";

package/dist/types/utilities/async-iterable/abortable-iterable/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/async-iterable/abortable-iterable/abortable-iterable";

package/dist/types/utilities/async-iterable/delay-iterable/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/async-iterable/delay-iterable/delay-iterable";

package/dist/types/utilities/async-iterable/delay-iterable/delay-iterable.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @module Async
+ */
+import type { TimeSpan } from "../../../utilities/_module";
+/**
+ * The <i>delayIterable</i> function adds delay to each iteration of <i>{@link AsyncIterable}</i> and the delay can be aborted by providing <i>abortSignal</i>.
+ * @group AsyncIterable utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @example
+ * ```ts
+ * import { delayIterable, TimeSpan } from "@daiso-tech/core";
+ *
+ * const iterable: AsyncIterable<void> = {
+ *   async *[Symbol.asyncIterator]() {
+ *     yield 1;
+ *     yield 2;
+ *     yield 3;
+ *     yield 4;
+ *     yield 5;
+ *   }
+ * }
+ *
+ * (async () => {
+ *   for await (const item of delayIterable(iterable, TimeSpan.fromSeconds(1))) {
+ *     console.log(item);
+ *   }
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { delayIterable, TimeSpan } from "@daiso-tech/core";
+ *
+ * const abortController = new AbortController();
+ * setTimeout(() => {
+ *  abortController.abort("My abort error");
+ * }, TimeSpan.fromSeconds(3).toMilliseconds());
+ *
+ * const iterable: AsyncIterable<void> = {
+ *   async *[Symbol.asyncIterator]() {
+ *     yield 1;
+ *     yield 2;
+ *     yield 3;
+ *     yield 4;
+ *     yield 5;
+ *   }
+ * }
+ *
+ * (async () => {
+ *   // Will throw AbortAsyncError
+ *   for await (const item of delayIterable(iterable, TimeSpan.fromSeconds(1), abortController.signal)) {
+ *     console.log(item);
+ *   }
+ * })();
+ * ```
+ */
+export declare function delayIterable<TValue>(iterable: AsyncIterable<TValue>, time: TimeSpan, abortSignal?: AbortSignal): AsyncIterable<TValue>;

package/dist/types/utilities/async-iterable/retry-iterable/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/async-iterable/retry-iterable/retry-iterable";

package/dist/types/utilities/async-iterable/retry-iterable/retry-iterable.d.ts

@@ -0,0 +1,86 @@
+import type { RetrySettings } from "../../../utilities/async/retry/_module";
+/**
+ * The <i>retryIterable</i> function will retry each iteration of {@link AsyncIterable} if it throws an error until given <i>settings.maxAttempts</i>.
+ * You can add timeout for each retry by passing <i>settings.retryTimeout</i> and <i>settings.abortSignal</i> for aborting it on your own.
+ * You can also customize the retry policy by passing <i>settings.retryPolicy</i> and custom backof policy by passing <i>settings.backoffPolicy</i>.
+ * @group AsyncIterable utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @throws {RetryAsyncError} {@link RetryAsyncError}
+ * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}
+ * @example
+ * ```ts
+ * import { retryIterable, TimeSpan, exponentialBackoffPolicy } from "@daiso-tech/core";
+ *
+ * const iterable: AsyncIterable<void> = {
+ *   async *[Symbol.asyncIterator]() {
+ *     yield 1;
+ *     throw new Error("My error mesasge");
+ *   }
+ * }
+ *
+ * (async () => {
+ *   // Will throw RetryAsyncError after failing 4:th attempt
+ *   for await (const item of retryIterable(iterable, {
+ *     // You can choose the max retry attempts
+ *     maxAttempts: 4,
+ *     // You can provide a custom backoff policy
+ *     backoffPolicy: exponentialBackoffPolicy(),
+ *     // You can choose what error to retry, this function will retry all errors thrown
+ *     retryPolicy: () => true,
+ *     // You can provide a timeout for each retry
+ *     retryTimeout: TimeSpan.fromMilliseconds(60_000),
+ *   })) {
+ *     console.log(item)
+ *   }
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { retryIterable, TimeSpan } from "@daiso-tech/core";
+ *
+ * const iterable: AsyncIterable<void> = {
+ *   async *[Symbol.asyncIterator]() {
+ *     yield 1;
+ *     throw new Error("My error mesasge");
+ *   }
+ * }
+ *
+ * (async () => {
+ *   const abortController = new AbortController();
+ *   abortController.abort("My abort message");
+ *
+ *   // Will be aborted by throwing AbortAsyncError
+ *   for await (const item of retry(iterable, {
+ *     abortSignal: abortController.signal
+ *   })) {
+ *     console.log(item)
+ *   }
+ * })();
+ * ```
+ * @example with abortSignal
+ * ```ts
+ * import { retryIterable, TimeSpan } from "@daiso-tech/core";
+ *
+ * class ErrorA extends Error {};
+ * class ErrorB extends Error {};
+ *
+ * const iterable: AsyncIterable<void> = {
+ *   async *[Symbol.asyncIterator]() {
+ *     yield 1;
+ *     throw new ErrorB("My error mesasge");
+ *   }
+ * }
+ *
+ *
+ * (async () => {
+ *   // Will not retry and ErrorB will be thrown
+ *   for await (const item of retry(iterable, {
+ *     retryPolicy: error => error instanceof ErrorA
+ *   })) {
+ *     console.log(item)
+ *   }
+ * })();
+ * ```
+ */
+export declare function retryIterable<TValue>(iterable: AsyncIterable<TValue>, settings?: RetrySettings): AsyncIterable<TValue>;

package/dist/types/utilities/async-iterable/timeout-iterable/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../utilities/async-iterable/timeout-iterable/timeout-iterable";