@daiso-tech/core 0.6.0 → 0.8.0

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

@@ -1,36 +0,0 @@
-/**
- * @module Async
- */
-/**
- * The <i>abortableIterable</i> function makes a <i>{@link AsyncIterable}</i> abortable.
- * @group AsyncIterable utilities
- * @throws {AsyncError} {@link AsyncError}
- * @throws {AbortAsyncError} {@link AbortAsyncError}
- * @example
- * ```ts
- * import { abortableIterable } from "@daiso-tech/core"
- *
- * let a = 0;
- * const abortController = new AbortController();
- * const iterable: AsyncIterable<void> = {
- *  async *[Symbol.asyncIterator]() {
- *    a = 1;
- *    abortController.abort("My abort");
- *    yield undefined;
- *    a = 2;
- *  }
- * }
- * const newIterable = abortableIterable(iterable, abortController.signal);
- * (async () => {
- *  try {
- *    // An error will be thrown
- *    for await (const _ of newIterable);
- *  }
- *  finally {
- *    // Will be 1
- *    console.log(a);
- *  }
- * })();
- * ```
- */
-export declare function abortableIterable<TValue>(iterable: AsyncIterable<TValue>, abortSignal: AbortSignal): AsyncIterable<TValue>;

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

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

package/dist/types/async/backof-policies/_shared.d.ts

@@ -1,12 +0,0 @@
-/**
- * @module Async
- */
-/**
- * @group Backoff policies
- * @returns Amount milliseconds to wait
- */
-export type BackoffPolicy = (attempt: number, error: unknown) => number;
-/**
- * @internal
- */
-export declare function withJitter(jitter: number, value: number, mathRandom: () => number): number;

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

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

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

@@ -1,28 +0,0 @@
-/**
- * @module Async
- */
-import { TimeSpan } from "../../../utilities/_module";
-import { type BackoffPolicy } from "../../../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/async/backof-policies/exponential-backoff-policy/_module.d.ts

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

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

@@ -1,36 +0,0 @@
-/**
- * @module Async
- */
-import { TimeSpan } from "../../../utilities/_module";
-import type { BackoffPolicy } from "../../../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/async/backof-policies/linear-backoff-policy/_module.d.ts

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

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

@@ -1,32 +0,0 @@
-/**
- * @module Async
- */
-import { TimeSpan } from "../../../utilities/_module";
-import type { BackoffPolicy } from "../../../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/async/backof-policies/polynomial-backoff-policy/_module.d.ts

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

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

@@ -1,36 +0,0 @@
-/**
- * @module Async
- */
-import { TimeSpan } from "../../../utilities/_module";
-import type { BackoffPolicy } from "../../../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/async/delay/_module.d.ts

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

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

@@ -1,38 +0,0 @@
-/**
- * @module Async
- */
-import type { TimeSpan } from "../../utilities/_module";
-import { LazyPromise } from "../../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/async/delay-iterable/_module.d.ts

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

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

@@ -1,57 +0,0 @@
-/**
- * @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/async/lazy-promise/_module.d.ts

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

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

@@ -1,28 +0,0 @@
-/**
- * @module Async
- */
-/**
- * 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.
- * @group Promise utilities
- * @example
- * ```ts
- * (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;
- * })();
- * ```
- */
-export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
-    private readonly asyncFn;
-    private promise;
-    constructor(asyncFn: () => PromiseLike<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>deferLazyPromise</i> function will execute <i>{@link LazyPromise}</i> without awaiting it.
- * @group Promise utilities
- */
-export declare function deferLazyPromise<TValue>(promise: LazyPromise<TValue>): void;

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

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

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

@@ -1,86 +0,0 @@
-/**
- * @module Async
- */
-import type { BackoffPolicy } from "../../async/backof-policies/_module";
-import { LazyPromise } from "../../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/async/retry-iterable/_module.d.ts

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

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

@@ -1,86 +0,0 @@
-import type { RetrySettings } from "../../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/async/timeout/_module.d.ts

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

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

@@ -1,40 +0,0 @@
-/**
- * @module Async
- */
-import { LazyPromise } from "../../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/async/timeout-iterable/_module.d.ts

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

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

@@ -1,64 +0,0 @@
-/**
- * @module Async
- */
-import type { TimeSpan } from "../../utilities/_module";
-/**
- * The <i>timeoutIterable</i> function makes a <i>{@link AsyncIterable}</i> abort after a given <i>time</i> and you can also abort it on your own by passing <i>abortSignal</i>.
- * @group AsyncIterable utilities
- * @throws {AsyncError} {@link AsyncError}
- * @throws {AbortAsyncError} {@link AbortAsyncError}
- * @example
- * ```ts
- * import { timeoutIterable, delayIterable, TimeSpan } from "@daiso-tech/core";
- *
- * const iterable: AsyncIterable<void> = delayIterable({
- *   async *[Symbol.asyncIterator]() {
- *     yield 1;
- *     yield 2;
- *     yield 3;
- *     yield 4;
- *     yield 5;
- *     yield 6;
- *     yield 7;
- *     yield 8;
- *   }
- * }, TimeSpan.fromSeconds(1));
- *
- * (async () => {
- *   // Will throw an AbortAsyncError
- *   for (const item of timeoutIterable(iterable, TimeSpan.fromSeconds(5))) {
- *     console.log(item);
- *   }
- * })();
- * ```
- * @example with abortSignal
- * ```ts
- * import { timeoutIterable, delay, TimeSpan } from "@daiso-tech/core";
- *
- * const iterable: AsyncIterable<void> = delayIterable({
- *   async *[Symbol.asyncIterator]() {
- *     yield 1;
- *     yield 2;
- *     yield 3;
- *     yield 4;
- *     yield 5;
- *     yield 6;
- *     yield 7;
- *     yield 8;
- *   }
- * }, TimeSpan.fromSeconds(1));
- *
- * const abortController = new AbortController();
- * setTimeout(() => {
- *  abortController.abort("My abort message");
- * }, TimeSpan.fromSeconds(3));
- *
- * (async () => {
- *   // Will abort after 3 second by throwing AbortAsyncError
- *   for (const item of timeoutIterable(iterable, TimeSpan.fromSeconds(5), abortController.signal)) {
- *     console.log(item);
- *   }
- * })();
- * ```
- */
-export declare function timeoutIterable<TValue>(iterable: AsyncIterable<TValue>, time: TimeSpan, abortSignal?: AbortSignal): AsyncIterable<TValue>;

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

@@ -1,4 +0,0 @@
-export * from "../collection/_shared";
-export * from "../collection/list-collection/_module";
-export * from "../collection/iterable-collection/_module";
-export * from "../collection/async-iterable-collection/_module";

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

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