@daiso-tech/core 0.6.0 → 0.8.0

package/dist/types/storage/implementations/redis-storage-adapter/redis-storage-adapter.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @module Storage
+ */
+import { type ISerializer } from "../../../serializer/contracts/_module";
+import { type IStorageAdapter } from "../../../storage/contracts/_module";
+import type Redis from "ioredis";
+import { type Result } from "ioredis";
+declare module "ioredis" {
+    interface RedisCommander<Context> {
+        daiso_storage_increment(key: string, number: string): Result<number, Context>;
+        daiso_storage_put(key: string, value: string): Result<string, Context>;
+        daiso_storage_getOrAdd(key: string, valueToAdd: string): Result<string, Context>;
+    }
+}
+/**
+ * @group Adapters
+ */
+export type RedisStorageAdapterSettings = {
+    serializer?: ISerializer<string>;
+};
+/**
+ * @group Adapters
+ */
+export declare class RedisStorageAdapter<TType> implements IStorageAdapter<TType> {
+    private readonly client;
+    private serializer;
+    constructor(client: Redis, { serializer, }?: RedisStorageAdapterSettings);
+    private initIncrementCommand;
+    private initPutCommand;
+    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    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/storage/implementations/sqlite/_module.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../storage/implementations/sqlite/sqlite-storage-adapter/_module";
+export * from "../../../storage/implementations/sqlite/libsql-storage-adapter/_module";

package/dist/types/storage/implementations/sqlite/_shared/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../storage/implementations/sqlite/_shared/base-sqlite-storage-adapter";

package/dist/types/storage/implementations/sqlite/_shared/base-sqlite-storage-adapter.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @module Storage
+ */
+import { type IStorageAdapter } from "../../../../storage/contracts/storage-adapter.contract";
+import { type Generated, type Kysely } from "kysely";
+import { type ISerializer } from "../../../../serializer/contracts/_module";
+import { type IInitizable } from "../../../../_shared/types";
+/**
+ * @internal
+ */
+type BaseSqliteStorageTable = {
+    key: string;
+    value: string;
+    hasBeenUpdated: Generated<1 | 0>;
+};
+/**
+ * @internal
+ */
+type BaseSqliteTables = {
+    storage: BaseSqliteStorageTable;
+};
+/**
+ * @internal
+ */
+export declare class BaseSqliteStorageAdapter<TType> implements IStorageAdapter<TType>, IInitizable {
+    private readonly db;
+    private readonly serializer;
+    constructor(db: Kysely<BaseSqliteTables>, serializer: ISerializer<string>);
+    init(): Promise<void>;
+    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    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>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    putMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}
+export {};

package/dist/types/storage/implementations/sqlite/libsql-storage-adapter/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../storage/implementations/sqlite/libsql-storage-adapter/libsql-storage-adapter";

package/dist/types/storage/implementations/sqlite/libsql-storage-adapter/libsql-storage-adapter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @module Storage
+ */
+import type { ISerializer } from "../../../../serializer/contracts/_module";
+import { type IStorageAdapter } from "../../../../storage/contracts/_module";
+import { type IInitizable } from "../../../../_shared/types";
+import type { Client } from "@libsql/client";
+/**
+ * @group Adapters
+ */
+export type LibsqlStorageAdapterSettings = {
+    tableName?: string;
+    serializer?: ISerializer<string>;
+};
+/**
+ * @group Adapters
+ */
+export declare class LibsqlStorageAdapter<TType> implements IStorageAdapter<TType>, IInitizable {
+    private readonly storageAdapter;
+    constructor(client: Client, { tableName, serializer, }?: LibsqlStorageAdapterSettings);
+    init(): Promise<void>;
+    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TType | null>>;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    addMany<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/storage/implementations/sqlite/sqlite-storage-adapter/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../storage/implementations/sqlite/sqlite-storage-adapter/sqlite-storage-adapter";

package/dist/types/storage/implementations/sqlite/sqlite-storage-adapter/sqlite-storage-adapter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @module Storage
+ */
+import type { ISerializer } from "../../../../serializer/contracts/_module";
+import { type IStorageAdapter } from "../../../../storage/contracts/_module";
+import { type Database } from "better-sqlite3";
+import { type IInitizable } from "../../../../_shared/types";
+/**
+ * @group Adapters
+ */
+export type SqliteStorageAdapterSettings = {
+    tableName?: string;
+    serializer?: ISerializer<string>;
+};
+/**
+ * @group Adapters
+ */
+export declare class SqliteStorageAdapter<TType> implements IStorageAdapter<TType>, IInitizable {
+    private readonly storageAdapter;
+    constructor(database: Database, { tableName, serializer, }?: SqliteStorageAdapterSettings);
+    init(): Promise<void>;
+    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    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/storage/implementations/storage/_module.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../storage/implementations/storage/storage";
+export * from "../../../storage/implementations/storage/storage-manager";

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

@@ -0,0 +1,23 @@
+/**
+ * @module Storage
+ */
+import type { INamespacedStorage, IStorageAdapter, IStorageManager, StorageManagerUseSettings } from "../../../storage/contracts/_module";
+import { type StorageSettings } from "../../../storage/implementations/storage/storage";
+/**
+ * @group Derivables
+ */
+export type StorageManagerSettings<TAdapters extends string = string> = {
+    adapters: Record<TAdapters, IStorageAdapter<any>>;
+    defaultAdapter: NoInfer<TAdapters>;
+    adapterSettings?: Omit<StorageSettings<any>, "validator">;
+};
+/**
+ * @group Derivables
+ */
+export declare class StorageManager<TAdapters extends string = string> implements IStorageManager<TAdapters> {
+    private readonly adapters;
+    private readonly defaultAdapter;
+    private readonly adapterSettings;
+    constructor(settings: StorageManagerSettings<TAdapters>);
+    use<TType>(adapterSettings?: StorageManagerUseSettings<TType, TAdapters>): INamespacedStorage<TType>;
+}

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

@@ -0,0 +1,114 @@
+/**
+ * @module Storage
+ */
+import { type IStorage, type IStorageAdapter } from "../../../storage/contracts/_module";
+import { type StorageValue, type INamespacedStorage, type AllStorageEvents } from "../../../storage/contracts/_module";
+import { type AsyncLazyable, type GetOrAddValue } from "../../../_shared/types";
+import type { Validator } from "../../../utilities/_module";
+import { LazyPromise } from "../../../utilities/_module";
+import type { INamespacedEventBus, Listener, SelectEvent, Unsubscribe } from "../../../event-bus/contracts/_module";
+/**
+ * @group Derivables
+ */
+export type StorageSettings<TType> = {
+    /**
+     * You can prefix all keys with a given <i>rootNamespace</i>.
+     * This useful if you want to add multitenancy but still use the same database.
+     * @default {""}
+     * @example
+     * ```ts
+     * import { Storage, MemoryStorageAdapter } from "@daiso-tech/core";
+     *
+     * const storageA = new Storage(new MemoryStorageAdapter(), {
+     *   rootNamespace: "@a/"
+     * });
+     * const storageB = new Storage(new MemoryStorageAdapter(), {
+     *   rootNamespace: "@b/"
+     * });
+     *
+     * (async () => {
+     *   await storageA.add("a", 1);
+     *
+     *   // Will be "a"
+     *   console.log(await storageA.get("a"));
+     *
+     *   // Will be "null"
+     *   console.log(await storageB.get("a"));
+     * })();
+     * ```
+     */
+    rootNamespace?: string;
+    /**
+     * You can pass a custom <i>{@link Validator}</i> to validate, transform and sanitize your data.
+     * You could also use <i>{@link zodValidator}</i> which enables you to use zod for validating, transforming, and sanitizing.
+     * @example
+     * ```ts
+     * import { Storage, MemoryStorageAdapter, zodValidator } from "@daiso-tech/core";
+     * import { z } from "zod";
+     *
+     * const storage = new Storage(new MemoryStorageAdapter(), {
+     *   // Type will be infered from validator
+     *   validator: zodValidator(z.string())
+     * });
+     *
+     * (async () => {
+     *   // An Typescript error will be seen and ValidationError will be thrown during runtime.
+     *   await storageA.add("a", 1);
+     * })();
+     * ```
+     */
+    validator?: Validator<TType>;
+    eventBus?: INamespacedEventBus<AllStorageEvents<TType>>;
+};
+/**
+ * <i>Storage</i> class can be derived from any <i>{@link IStorageAdapter}</i>.
+ * @group Derivables
+ */
+export declare class Storage<TType = unknown> implements INamespacedStorage<TType> {
+    private readonly storageAdapter;
+    static EVENTS: {
+        readonly KEYS_FOUND: "keys_found";
+        readonly KEYS_NOT_FOUND: "keys_not_found";
+        readonly KEYS_ADDED: "keys_added";
+        readonly KEYS_UPDATED: "keys_updated";
+        readonly KEYS_REMOVED: "keys_removed";
+        readonly KEYS_CLEARED: "keys_cleared";
+        readonly KEY_INCREMENTED: "key_incremented";
+        readonly KEY_DECREMENTED: "key_decremented";
+    };
+    private readonly withEventStorageAdapter;
+    private readonly namespace_;
+    private readonly validator;
+    private readonly eventBus;
+    constructor(storageAdapter: IStorageAdapter<any>, settings?: StorageSettings<TType>);
+    addListener<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<void>;
+    addListenerMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<void>;
+    removeListener<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<void>;
+    removeListenerMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<void>;
+    subscribe<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<Unsubscribe>;
+    subscribeMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<Unsubscribe>;
+    withNamespace(namespace: string): IStorage<TType>;
+    getNamespace(): string;
+    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-event-storage-adapter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @module Storage
+ */
+import type { StorageEvent } from "../../../storage/contracts/_module";
+import { type IStorageAdapter, type AllStorageEvents } from "../../../storage/contracts/_module";
+import type { IEventBus } from "../../../event-bus/contracts/_module";
+import type { WithNamespaceStorageAdapter } from "../../../storage/implementations/storage/with-namespace-storage-adapter";
+/**
+ * @internal
+ */
+export declare class WithEventStorageAdapter<TType> implements Required<Omit<IStorageAdapter<TType>, "clear">> {
+    private readonly withNamespaceStorageAdapter;
+    private readonly eventBus;
+    private readonly eventAttributes;
+    constructor(withNamespaceStorageAdapter: WithNamespaceStorageAdapter<TType>, eventBus: IEventBus<AllStorageEvents<TType>>, eventAttributes: StorageEvent);
+    private triggerGetManyEvents;
+    getMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TType | null>>;
+    private triggerAddManyEvents;
+    addMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    private triggerUpdateManyEvents;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    private triggerPutManyEvents;
+    putMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    private triggerRemoveManyEvents;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    private triggerIncrementEvents;
+    private triggerDecrementEvents;
+    increment(key: string, value: number): Promise<boolean>;
+    private triggerClearEvents;
+    clear(): Promise<void>;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * @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>;
+    clear(): Promise<void>;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * @module Storage
+ */
+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,4 @@
+export * from "../utilities/async/_module";
+export * from "../utilities/backof-policies/_module";
 export * from "../utilities/time-span/_module";
+export * from "../utilities/validation/_module";

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

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

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

@@ -0,0 +1,35 @@
+/**
+ * @module Utilities
+ */
+/**
+ * @group Async
+ */
+export declare class AsyncError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Async
+ */
+export declare class AbortAsyncError extends AsyncError {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Async
+ */
+export declare class TimeoutAsyncError extends AsyncError {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Async
+ */
+export type RetryAsyncErrorData = {
+    cause?: unknown;
+    maxAttempts: number;
+};
+/**
+ * @group Async
+ */
+export declare class RetryAsyncError extends AsyncError {
+    readonly maxAttempts: number;
+    constructor(message: string, { cause, maxAttempts }: RetryAsyncErrorData);
+}

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 Utilities
+ */
+import { LazyPromise } from "../../../utilities/async/lazy-promise/_module";
+/**
+ * The <i>abortable</i> function makes a <i>{@link PromiseLike}</i> object abortable.
+ * @group Async 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/abortable-iterable/_module.d.ts

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

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

@@ -0,0 +1,36 @@
+/**
+ * @module Utilities
+ */
+/**
+ * The <i>abortableIterable</i> function makes a <i>{@link AsyncIterable}</i> abortable.
+ * @group Async 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/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 Utilities
+ */
+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 Async 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/delay-iterable/_module.d.ts

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

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

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

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

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

@@ -0,0 +1,28 @@
+/**
+ * @module Utilities
+ */
+/**
+ * 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 Async 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 Async utilities
+ */
+export declare function deferLazyPromise<TValue>(promise: LazyPromise<TValue>): void;