@duplojs/utils 1.3.32 → 1.4.33

package/dist/clean/primitive/operations/time/timeLessThan.d.ts

@@ -1,4 +1,28 @@
 import { type Time } from "../../base";
 import { type TheTime } from "../../../../date";
+/**
+ * Checks whether a Time is less than a threshold.
+ * 
+ * **Supported call styles:**
+ * - Classic: `timeLessThan(time, threshold)` -> returns a boolean
+ * - Curried: `timeLessThan(threshold)` -> returns a function waiting for the time
+ * 
+ * Use it to compare wrapped durations or raw TheTime values.
+ * 
+ * ```ts
+ * const duration = C.Time.createOrThrow(D.createTheTime(3_600_000));
+ * const threshold = D.createTheTime(7_200_000);
+ * 
+ * if (C.timeLessThan(duration, threshold)) {
+ * 	// duration is less than threshold
+ * }
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/timeLessThan
+ * 
+ * @namespace C
+ * 
+ */
 export declare function timeLessThan(threshold: Time | TheTime): (primitive: Time) => boolean;
 export declare function timeLessThan(primitive: Time, threshold: Time | TheTime): boolean;

package/dist/clean/primitive/operations/time/timeMax.cjs

@@ -5,6 +5,9 @@ var createTheTime = require('../../../../date/createTheTime.cjs');
 var unwrap = require('../../../../common/unwrap.cjs');
 var toTimeValue = require('../../../../date/toTimeValue.cjs');
 
+/**
+ * {@include clean/timeMax/index.md}
+ */
 function timeMax(input) {
     return wrapValue.wrapValue(createTheTime.createTheTime(Math.max(...input.map(unwrap.unwrap).map(toTimeValue.toTimeValue))));
 }

package/dist/clean/primitive/operations/time/timeMax.d.ts

@@ -1,4 +1,40 @@
 import { type TheTime } from "../../../../date";
 import { type Time } from "../../base";
 import { type AnyTuple } from "../../../../common";
+/**
+ * Returns the largest duration from a tuple of Time values.
+ * 
+ * **Supported call styles:**
+ * - Classic: `timeMax(input)` -> returns a Time
+ * 
+ * The input can mix wrapped Times and raw TheTime values.
+ * 
+ * ```ts
+ * const largest = C.timeMax([
+ * 	C.Time.createOrThrow(D.createTheTime(1_000)),
+ * 	D.createTheTime(500),
+ * 	D.createTheTime(2_000),
+ * ]);
+ * // largest: C.Time
+ * 
+ * const fromRaw = C.timeMax([
+ * 	D.createTheTime(10),
+ * 	D.createTheTime(5),
+ * 	D.createTheTime(20),
+ * ]);
+ * // fromRaw: C.Time
+ * 
+ * const mixed = C.timeMax([
+ * 	C.Time.createOrThrow(D.createTheTime(100)),
+ * 	D.createTheTime(50),
+ * ]);
+ * // mixed: C.Time
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/timeMax
+ * 
+ * @namespace C
+ * 
+ */
 export declare function timeMax(input: AnyTuple<Time | TheTime>): Time;

package/dist/clean/primitive/operations/time/timeMax.mjs

@@ -3,6 +3,9 @@ import { createTheTime } from '../../../../date/createTheTime.mjs';
 import { unwrap } from '../../../../common/unwrap.mjs';
 import { toTimeValue } from '../../../../date/toTimeValue.mjs';
 
+/**
+ * {@include clean/timeMax/index.md}
+ */
 function timeMax(input) {
     return wrapValue(createTheTime(Math.max(...input.map(unwrap).map(toTimeValue))));
 }

package/dist/clean/primitive/operations/time/timeMin.cjs

@@ -5,6 +5,9 @@ var wrapValue = require('../../../../common/wrapValue.cjs');
 var createTheTime = require('../../../../date/createTheTime.cjs');
 var unwrap = require('../../../../common/unwrap.cjs');
 
+/**
+ * {@include clean/timeMin/index.md}
+ */
 function timeMin(input) {
     return wrapValue.wrapValue(createTheTime.createTheTime(Math.min(...input.map(unwrap.unwrap).map(toTimeValue.toTimeValue))));
 }

package/dist/clean/primitive/operations/time/timeMin.d.ts

@@ -1,4 +1,40 @@
 import { type TheTime } from "../../../../date";
 import { type Time } from "../../base";
 import { type AnyTuple } from "../../../../common";
+/**
+ * Returns the smallest duration from a tuple of Time values.
+ * 
+ * **Supported call styles:**
+ * - Classic: `timeMin(input)` -> returns a Time
+ * 
+ * The input can mix wrapped Times and raw TheTime values.
+ * 
+ * ```ts
+ * const smallest = C.timeMin([
+ * 	C.Time.createOrThrow(D.createTheTime(1_000)),
+ * 	D.createTheTime(500),
+ * 	D.createTheTime(2_000),
+ * ]);
+ * // smallest: C.Time
+ * 
+ * const fromRaw = C.timeMin([
+ * 	D.createTheTime(10),
+ * 	D.createTheTime(5),
+ * 	D.createTheTime(20),
+ * ]);
+ * // fromRaw: C.Time
+ * 
+ * const mixed = C.timeMin([
+ * 	C.Time.createOrThrow(D.createTheTime(100)),
+ * 	D.createTheTime(50),
+ * ]);
+ * // mixed: C.Time
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/timeMin
+ * 
+ * @namespace C
+ * 
+ */
 export declare function timeMin(input: AnyTuple<Time | TheTime>): Time;

package/dist/clean/primitive/operations/time/timeMin.mjs

@@ -3,6 +3,9 @@ import { wrapValue } from '../../../../common/wrapValue.mjs';
 import { createTheTime } from '../../../../date/createTheTime.mjs';
 import { unwrap } from '../../../../common/unwrap.mjs';
 
+/**
+ * {@include clean/timeMin/index.md}
+ */
 function timeMin(input) {
     return wrapValue(createTheTime(Math.min(...input.map(unwrap).map(toTimeValue))));
 }

package/dist/clean/repository.cjs

@@ -3,6 +3,9 @@
 var kind = require('./kind.cjs');
 
 const repositoryHandlerKind = kind.createCleanKind("repository-handler");
+/**
+ * {@include clean/createRepository/index.md}
+ */
 function createRepository() {
     return repositoryHandlerKind.setTo({
         createImplementation(implementation) {

package/dist/clean/repository.d.ts

@@ -1,8 +1,95 @@
 import { type SimplifyTopLevel, type AnyFunction, type Kind } from "../common";
 export declare const repositoryHandlerKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsClean/repository-handler", unknown>>;
 export interface RepositoryHandler<GenericRepository extends object = object> extends Kind<typeof repositoryHandlerKind.definition> {
+    /**
+     * Returns the implementation after verifying it matches the repository contract.
+     * 
+     * ```ts
+     * // Infrastructure Layer
+     * const userRepository = UserRepository.createImplementation({
+     * 	findById(userId) {
+     * 		// database call
+     * 		const user = User.Entity.mapOrThrow({
+     * 			id: unwrap(userId),
+     * 			nickname: "Daniel",
+     * 			roles: ["manager"],
+     * 		});
+     * 
+     * 		return Promise.resolve(E.success(user));
+     * 	},
+     * });
+     * ```
+     * 
+     */
     createImplementation(implementation: SimplifyTopLevel<{
         [Prop in keyof GenericRepository]: GenericRepository[Prop] extends AnyFunction ? (...args: Parameters<GenericRepository[Prop]>) => ReturnType<GenericRepository[Prop]> : GenericRepository[Prop];
     }>): GenericRepository;
 }
+/**
+ * Creates a repository handler for a contract interface.
+ * 
+ * **Supported call styles:**
+ * - Classic: `createRepository<Repository>()` -> returns a handler
+ * 
+ * The handler enforces the repository contract at compile time and stays runtime-free. It is meant to be composed with use cases.
+ * 
+ * ```ts
+ * // Domain Layer
+ * export namespace User {
+ * 	export const Id = C.createNewType("UserId", DP.number(), C.Positive);
+ * 	export type Id = C.GetNewType<typeof Id>;
+ * 
+ * 	export const Nickname = C.createNewType("UserNickname", DP.string());
+ * 	export type Nickname = C.GetNewType<typeof Nickname>;
+ * 
+ * 	export const Role = C.createNewType("UserRole", DP.literal(["admin", "client", "manager"]));
+ * 	export type Role = C.GetNewType<typeof Role>;
+ * 
+ * 	export const Entity = C.createEntity("User", ({ array }) => ({
+ * 		id: Id,
+ * 		nickname: Nickname,
+ * 		roles: array(Role, { min: 1 }),
+ * 	}));
+ * 	export type Entity = C.GetEntity<typeof Entity>;
+ * }
+ * 
+ * // Application Layer
+ * interface UserRepository {
+ * 	findById(id: User.Id): Promise<E.EitherSuccess<User.Entity> | E.EitherFail>;
+ * }
+ * 
+ * const UserRepository = C.createRepository<UserRepository>();
+ * 
+ * const FindUserUseCase = C.createUseCase(
+ * 	{ UserRepository },
+ * 	(
+ * 		{ userRepository },
+ * 	) => (userId: User.Id) => userRepository.findById(userId),
+ * );
+ * 
+ * // Infrastructure Layer
+ * const userRepository = UserRepository.createImplementation({
+ * 	findById(userId) {
+ * 		// database call
+ * 		const user = User.Entity.mapOrThrow({
+ * 			id: unwrap(userId),
+ * 			nickname: "Daniel",
+ * 			roles: ["manager"],
+ * 		});
+ * 
+ * 		return Promise.resolve(E.success(user));
+ * 	},
+ * });
+ * 
+ * 
+ * ```
+ * 
+ * @remarks
+ * - This helper adds no runtime logic; it only validates the contract at compile time.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/repository
+ * 
+ * @namespace C
+ * 
+ */
 export declare function createRepository<GenericRepository extends object>(): RepositoryHandler<GenericRepository>;

package/dist/clean/repository.mjs

@@ -1,6 +1,9 @@
 import { createCleanKind } from './kind.mjs';
 
 const repositoryHandlerKind = createCleanKind("repository-handler");
+/**
+ * {@include clean/createRepository/index.md}
+ */
 function createRepository() {
     return repositoryHandlerKind.setTo({
         createImplementation(implementation) {

package/dist/clean/useCase.cjs

@@ -9,6 +9,9 @@ var entries = require('../object/entries.cjs');
 var fromEntries = require('../object/fromEntries.cjs');
 
 const useCaseHandlerKind = kind.createCleanKind("use-case-handler");
+/**
+ * {@include clean/createUseCase/index.md}
+ */
 function createUseCase(dependencies, getUseCase) {
     return useCaseHandlerKind.setTo({
         dependencies,
@@ -17,6 +20,9 @@ function createUseCase(dependencies, getUseCase) {
             : repositories[uncapitalize.uncapitalize(key)])), fromEntries.fromEntries)),
     });
 }
+/**
+ * {@include clean/useCaseInstances/index.md}
+ */
 function useCaseInstances(useCases, repositories) {
     return pipe.pipe(useCases, entries.entries, map.map(([key, useCase]) => entry.entry(uncapitalize.uncapitalize(key), useCase.getUseCase(repositories))), fromEntries.fromEntries);
 }

package/dist/clean/useCase.d.ts

@@ -12,12 +12,152 @@ export type GetAllRepositories<GenericDependenciesValue extends UseCaseDependenc
 })[keyof GenericDependenciesValue] : never;
 export declare const useCaseHandlerKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsClean/use-case-handler", unknown>>;
 export interface UseCaseHandler<GenericDependencies extends UseCaseDependencies = any, GenericUseCase extends (input: any) => any = any> extends Kind<typeof useCaseHandlerKind.definition> {
+    /**
+     * The dependency definition (repository handlers and/or use case handlers).
+     * 
+     */
     dependencies: GenericDependencies;
+    /**
+     * Instantiates the use case with repository implementations.
+     * 
+     * ```ts
+     * // instance one use case
+     * const findUserUseCase = FindUserUseCase.getUseCase({ userRepository });
+     * ```
+     * 
+     */
     getUseCase(repositories: (GetAllRepositories<GenericDependencies> extends infer InferredEntriesDependenciesValue extends ObjectEntry ? {
         [Entry in InferredEntriesDependenciesValue as InferredEntriesDependenciesValue[0]]: InferredEntriesDependenciesValue[1];
     } : never)): GenericUseCase;
 }
+/**
+ * Creates a use case handler with explicit dependencies.
+ * 
+ * **Supported call styles:**
+ * - Classic: `createUseCase(dependencies, getUseCase)` -> returns a handler
+ * 
+ * This separates declaration (dependencies + factory) from instantiation (repositories). Sub-use-cases are resolved automatically during instantiation.
+ * 
+ * ```ts
+ * // Domain Layer
+ * export namespace User {
+ * 	export const Id = C.createNewType("UserId", DP.number(), C.Positive);
+ * 	export type Id = C.GetNewType<typeof Id>;
+ * 
+ * 	export const Nickname = C.createNewType("UserNickname", DP.string());
+ * 	export type Nickname = C.GetNewType<typeof Nickname>;
+ * 
+ * 	export const Role = C.createNewType("UserRole", DP.literal(["admin", "client", "manager"]));
+ * 	export type Role = C.GetNewType<typeof Role>;
+ * 
+ * 	export const Entity = C.createEntity("User", ({ array }) => ({
+ * 		id: Id,
+ * 		nickname: Nickname,
+ * 		roles: array(Role, { min: 1 }),
+ * 	}));
+ * 	export type Entity = C.GetEntity<typeof Entity>;
+ * }
+ * 
+ * // Application Layer
+ * interface UserRepository {
+ * 	findById(id: User.Id): Promise<E.EitherSuccess<User.Entity> | E.EitherFail>;
+ * }
+ * 
+ * const UserRepository = C.createRepository<UserRepository>();
+ * 
+ * const FindUserUseCase = C.createUseCase(
+ * 	{ UserRepository },
+ * 	(
+ * 		{ userRepository },
+ * 	) => (userId: User.Id) => userRepository.findById(userId),
+ * );
+ * 
+ * // Infrastructure Layer
+ * const userRepository = UserRepository.createImplementation({
+ * 	findById(userId) {
+ * 		// database call
+ * 		const user = User.Entity.mapOrThrow({
+ * 			id: unwrap(userId),
+ * 			nickname: "Daniel",
+ * 			roles: ["manager"],
+ * 		});
+ * 
+ * 		return Promise.resolve(E.success(user));
+ * 	},
+ * });
+ * 
+ * // instance one use case
+ * const findUserUseCase = FindUserUseCase.getUseCase({ userRepository });
+ * 
+ * // instance many use cases
+ * const useCases = C.useCaseInstances(
+ * 	{
+ * 		FindUserUseCase,
+ * 		//...
+ * 	},
+ * 	{
+ * 		userRepository,
+ * 		//...
+ * 	},
+ * );
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/useCase
+ * 
+ * @namespace C
+ * 
+ */
 export declare function createUseCase<const GenericDependencies extends UseCaseDependencies, GenericUseCase extends (input: any) => any>(dependencies: GenericDependencies, getUseCase: (dependenciesValue: UseCaseDependenciesValue<GenericDependencies>) => GenericUseCase): UseCaseHandler<GenericDependencies, GenericUseCase>;
+/**
+ * Instantiates multiple use cases at once.
+ * 
+ * **Supported call styles:**
+ * - Classic: `useCaseInstances(useCases, repositories)` -> returns use case functions
+ * 
+ * It maps dependency handlers to their implementations and returns an object of executable use cases with matching keys.
+ * 
+ * ```ts
+ * interface UserRepository {
+ * 	findById(id: number): Promise<string | null>;
+ * }
+ * 
+ * const UserRepository = C.createRepository<UserRepository>();
+ * 
+ * const FindUser = C.createUseCase(
+ * 	{ UserRepository },
+ * 	({ userRepository }) => async(id: number) => userRepository.findById(id),
+ * );
+ * 
+ * const CountUser = C.createUseCase(
+ * 	{ UserRepository },
+ * 	({ userRepository }) => async() => (await userRepository.findById(1) ? 1 : 0),
+ * );
+ * 
+ * const repository = UserRepository.createImplementation({
+ * 	findById(id) {
+ * 		return Promise.resolve(id === 1 ? "Ada" : null);
+ * 	},
+ * });
+ * 
+ * const useCases = C.useCaseInstances(
+ * 	{
+ * 		FindUser,
+ * 		CountUser,
+ * 	},
+ * 	{ userRepository: repository },
+ * );
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Returned keys are the uncapitalized version of the handler keys.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/useCase
+ * 
+ * @namespace C
+ * 
+ */
 export declare function useCaseInstances<GenericUseCases extends Record<string, UseCaseHandler>>(useCases: GenericUseCases, repositories: SimplifyTopLevel<UnionToIntersection<{
     [Prop in keyof GenericUseCases]: Parameters<GenericUseCases[Prop]["getUseCase"]>[0];
 }[keyof GenericUseCases]>>): UseCaseDependenciesValue<GenericUseCases>;

package/dist/clean/useCase.mjs

@@ -7,6 +7,9 @@ import { entries } from '../object/entries.mjs';
 import { fromEntries } from '../object/fromEntries.mjs';
 
 const useCaseHandlerKind = createCleanKind("use-case-handler");
+/**
+ * {@include clean/createUseCase/index.md}
+ */
 function createUseCase(dependencies, getUseCase) {
     return useCaseHandlerKind.setTo({
         dependencies,
@@ -15,6 +18,9 @@ function createUseCase(dependencies, getUseCase) {
             : repositories[uncapitalize(key)])), fromEntries)),
     });
 }
+/**
+ * {@include clean/useCaseInstances/index.md}
+ */
 function useCaseInstances(useCases, repositories) {
     return pipe(useCases, entries, map(([key, useCase]) => entry(uncapitalize(key), useCase.getUseCase(repositories))), fromEntries);
 }

package/dist/common/addWrappedProperties.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include common/addWrappedProperties/index.md}
+ */
 function addWrappedProperties(wrappedValue, getProperties) {
     const properties = getProperties({
         wrappedValue,

package/dist/common/addWrappedProperties.d.ts

@@ -1,4 +1,16 @@
 export type GetWrappedProperties<GenericWrappedValue extends object = object, GenericProperties extends object = object> = (params: {
     wrappedValue: GenericWrappedValue;
 }) => GenericProperties;
+/**
+ * The addWrappedProperties() function dynamically adds derived properties to a wrapped value while keeping the original type and extending the new type.
+ * 
+ * Signature: `addWrappedProperties(input, properties)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/addWrappedProperties
+ * 
+ * @namespace C
+ * 
+ */
 export declare function addWrappedProperties<GenericWrappedValue extends object, GenericGetWrappedProperties extends GetWrappedProperties<GenericWrappedValue>>(wrappedValue: GenericWrappedValue, getProperties: GenericGetWrappedProperties): GenericWrappedValue & ReturnType<GenericGetWrappedProperties>;

package/dist/common/addWrappedProperties.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include common/addWrappedProperties/index.md}
+ */
 function addWrappedProperties(wrappedValue, getProperties) {
     const properties = getProperties({
         wrappedValue,

package/dist/common/and.d.ts

@@ -8,6 +8,59 @@ type ExtractPredicate<GenericInput extends unknown, GenericPredicatedInput exten
     ...infer InferredRest extends AnyFunction<any[], boolean>[]
 ] ? InferredRest extends readonly [] ? InferredPredicate : InferredPredicate | ExtractPredicate<GenericInput, InferredRest> : GenericInput;
 type ComputeResult<GenericInput extends unknown, GenericPredicatedInput extends AnyFunction<any[], boolean>[]> = ExtractIntersection<GenericInput, GenericPredicatedInput> extends infer InferredResult extends GenericInput ? IsEqual<InferredResult, never> extends true ? GenericInput & UnionToIntersection<ExtractPredicate<GenericInput, GenericPredicatedInput>> : InferredResult : never;
+/**
+ * The and() function combines several predicates or type guards. All must succeed for the result to be true and the type to be narrowed to the intersection.
+ * 
+ * **Supported call styles:**
+ * - Classic: `and(input, predicates)` → returns a value
+ * - Curried: `and(predicates)` → returns a function waiting for the input
+ * - Classic predicate: `and(input, predicates)` → narrows the input type
+ * - Curried predicate: `and(predicates)` → narrows the input type
+ * 
+ * Predicate overloads (type guards) narrow the output type.
+ * 
+ * ```ts
+ * interface Admin {
+ * 	type: "admin";
+ * 	status: "active";
+ * 	meta: {
+ * 		role: "super";
+ * 	};
+ * }
+ * 
+ * interface Viewer {
+ * 	type: "viewer";
+ * 	status: "active";
+ * 	meta: {
+ * 		role: "reader";
+ * 	};
+ * }
+ * 
+ * const result = pipe(
+ * 	{
+ * 		type: "admin",
+ * 		status: "active",
+ * 		meta: {
+ * 			role: "super",
+ * 		},
+ * 	} as Admin | Viewer,
+ * 	when(
+ * 		and([
+ * 			DObject.discriminate("type", "admin"),
+ * 			DObject.discriminate("status", "active"),
+ * 		]),
+ * 		(value) => {
+ * 			// type: Admin
+ * 		},
+ * 	),
+ * );
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/and
+ * 
+ * @namespace C
+ * 
+ */
 export declare function and<GenericInput extends unknown, GenericArrayPredicatedInput extends [
     (input: GenericInput) => input is any,
     (input: GenericInput) => input is any,

package/dist/common/asyncInnerPipe.d.ts

@@ -2,6 +2,55 @@ import { type MaybeFutureEither } from "../either/future/maybeFutureEither";
 import { type MaybePromise, type EscapeVoid, type BreakGenericLink } from "./types";
 import { type AnyValue } from "./types/anyValue";
 type MaybePromiseLike<GenericValue extends unknown> = MaybePromise<GenericValue> | MaybeFutureEither<GenericValue>;
+/**
+ * The asyncInnerPipe() method builds a reusable asynchronous pipeline. It returns a function that accepts a value or a promise, runs each step while waiting for the previous one, then returns a promise of the final result.
+ * 
+ * Signature: `asyncInnerPipe(pipe1, pipe2)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = [
+ * 	{
+ * 		host: "api.local",
+ * 		retries: 1,
+ * 	},
+ * 	{
+ * 		host: "api.external",
+ * 		retries: 2,
+ * 	},
+ * ];
+ * 
+ * const result = await asyncPipe(
+ * 	input,
+ * 	A.map(
+ * 		asyncInnerPipe(
+ * 			({ host, retries }) => ({
+ * 				url: `https://${host}/health`,
+ * 				retries,
+ * 			}),
+ * 			// fake HTTP request
+ * 			async({ url, retries }) => Promise.resolve({
+ * 				url,
+ * 				status: 200,
+ * 				retries,
+ * 			}),
+ * 			({ status, url, retries }) => `${status} on ${url} (retries: ${retries})`,
+ * 		),
+ * 	),
+ * );
+ * // result: [
+ * //    "result: "200 on https://api.local/health (retries: 1)",
+ * //    "result: "200 on https://api.external/health (retries: 2)"
+ * // ]
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/asyncInnerPipe
+ * 
+ * @namespace C
+ * 
+ */
 export declare function asyncInnerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid>(pipe1: (input: GenericInput) => MaybePromiseLike<GenericOutputPipe1>): (input: MaybePromiseLike<GenericInput>) => Promise<Awaited<BreakGenericLink<GenericOutputPipe1>>>;
 export declare function asyncInnerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid>(pipe1: (input: GenericInput) => MaybePromiseLike<GenericOutputPipe1>, pipe2: (input: GenericOutputPipe1) => MaybePromiseLike<GenericOutputPipe2>): (input: MaybePromiseLike<GenericInput>) => Promise<Awaited<BreakGenericLink<GenericOutputPipe2>>>;
 export declare function asyncInnerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid>(pipe1: (input: GenericInput) => MaybePromiseLike<GenericOutputPipe1>, pipe2: (input: GenericOutputPipe1) => MaybePromiseLike<GenericOutputPipe2>, pipe3: (input: GenericOutputPipe2) => MaybePromiseLike<GenericOutputPipe3>): (input: MaybePromiseLike<GenericInput>) => Promise<Awaited<BreakGenericLink<GenericOutputPipe3>>>;

package/dist/common/asyncLoop.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include common/asyncLoop/index.md}
+ */
 async function asyncLoop(loop) {
     let previousOutput = undefined;
     for (let count = 0; true; count++) {

package/dist/common/asyncLoop.d.ts

@@ -6,5 +6,34 @@ interface LoopOutputExistResult<GenericOutput extends any> {
 interface LoopOutputNextResult<GenericOutput extends any> {
     "-nextData": GenericOutput;
 }
+/**
+ * The asyncLoop() function is the asynchronous variant of loop. Each iteration can return a promise before deciding to continue (next) or exit (exit).
+ * 
+ * Signature: `asyncLoop(from, theFunction)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const result = await asyncLoop<number, number>(
+ * 	async({ count, previousOutput, next, exit }) => {
+ * 		const current = (previousOutput ?? 0) + 1;
+ * 
+ * 		await Promise.resolve();
+ * 
+ * 		if (count >= 2) {
+ * 			return exit(current);
+ * 		}
+ * 
+ * 		return next(current);
+ * 	},
+ * );
+ * // result: 3
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/asyncLoop
+ * 
+ * @namespace C
+ * 
+ */
 export declare function asyncLoop<GenericRawExitOutput extends AnyValue = undefined, GenericRawNextOutput extends AnyValue = undefined>(loop: (params: LoopParams<GenericRawNextOutput>) => Promise<LoopOutputNextResult<GenericRawNextOutput | undefined> | LoopOutputExistResult<GenericRawExitOutput>>): Promise<GenericRawExitOutput>;
 export {};

package/dist/common/asyncLoop.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include common/asyncLoop/index.md}
+ */
 async function asyncLoop(loop) {
     let previousOutput = undefined;
     for (let count = 0; true; count++) {