@duplojs/utils 1.4.50 → 1.4.52

package/dist/clean/constraint/defaultConstraint/number.cjs

@@ -18,7 +18,21 @@ const Positive = base.createConstraint("positive", base$1.Number, min.checkerNum
  * {@include clean/Negative/index.md}
  */
 const Negative = base.createConstraint("negative", base$1.Number, max.checkerNumberMax(-1));
+/**
+ * {@include clean/NumberMin/index.md}
+ */
+function NumberMin(value) {
+    return base.createConstraint(`number-min-${value}`, base$1.Number, min.checkerNumberMin(value));
+}
+/**
+ * {@include clean/NumberMax/index.md}
+ */
+function NumberMax(value) {
+    return base.createConstraint(`number-max-${value}`, base$1.Number, max.checkerNumberMax(value));
+}
 
 exports.Int = Int;
 exports.Negative = Negative;
+exports.NumberMax = NumberMax;
+exports.NumberMin = NumberMin;
 exports.Positive = Positive;

package/dist/clean/constraint/defaultConstraint/number.d.ts

@@ -1,5 +1,6 @@
 import { type GetConstraint } from "../base";
 import * as DDataParser from "../../../dataParser";
+import { type OnlyLiteralNumber } from "../../../common";
 /**
  * Constraint handler that validates integer numbers.
  * 
@@ -87,3 +88,63 @@ export type Positive = GetConstraint<typeof Positive>;
  */
 export declare const Negative: import("..").ConstraintHandler<"negative", number, readonly [DDataParser.DataParserCheckerNumberMax]>;
 export type Negative = GetConstraint<typeof Negative>;
+/**
+ * Constraint factory that validates numbers greater than or equal to a minimum.
+ * 
+ * **Supported call styles:**
+ * - Classic: `NumberMin(min)` -> returns a constraint handler
+ * 
+ * Creates a constraint handler for `C.Number` that enforces a value greater than or equal to `min`. Use it to validate inputs and to constrain NewTypes with a minimum value requirement.
+ * 
+ * ```ts
+ * const AdultMin = C.NumberMin(18);
+ * 
+ * const result = AdultMin.create(18);
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.Right<"createConstrainedType", C.ConstrainedType<"number-min-18", 18>>
+ * }
+ * 
+ * const age = AdultMin.createOrThrow(20);
+ * // age: C.ConstrainedType<"number-min-18", 20>
+ * 
+ * AdultMin.is(age); // type guard
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
+export declare function NumberMin<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`number-min-${GenericValue & OnlyLiteralNumber<GenericValue>}`, number, readonly [DDataParser.DataParserCheckerNumberMin]>;
+export type NumberMin<GenericValue extends number> = ReturnType<typeof NumberMin<GenericValue>>;
+/**
+ * Constraint factory that validates numbers less than or equal to a maximum.
+ * 
+ * **Supported call styles:**
+ * - Classic: `NumberMax(max)` -> returns a constraint handler
+ * 
+ * Creates a constraint handler for `C.Number` that enforces a value less than or equal to `max`. Use it to validate inputs and to constrain NewTypes with a maximum value requirement.
+ * 
+ * ```ts
+ * const PercentMax = C.NumberMax(100);
+ * 
+ * const result = PercentMax.create(100);
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.Right<"createConstrainedType", C.ConstrainedType<"number-max-100", 100>>
+ * }
+ * 
+ * const value = PercentMax.createOrThrow(80);
+ * // value: C.ConstrainedType<"number-max-100", 80>
+ * 
+ * PercentMax.is(value); // type guard
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
+export declare function NumberMax<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`number-max-${GenericValue & OnlyLiteralNumber<GenericValue>}`, number, readonly [DDataParser.DataParserCheckerNumberMax]>;
+export type NumberMax<GenericValue extends number> = ReturnType<typeof NumberMax<GenericValue>>;

package/dist/clean/constraint/defaultConstraint/number.mjs

@@ -16,5 +16,17 @@ const Positive = createConstraint("positive", Number, checkerNumberMin(1));
  * {@include clean/Negative/index.md}
  */
 const Negative = createConstraint("negative", Number, checkerNumberMax(-1));
+/**
+ * {@include clean/NumberMin/index.md}
+ */
+function NumberMin(value) {
+    return createConstraint(`number-min-${value}`, Number, checkerNumberMin(value));
+}
+/**
+ * {@include clean/NumberMax/index.md}
+ */
+function NumberMax(value) {
+    return createConstraint(`number-max-${value}`, Number, checkerNumberMax(value));
+}
 
-export { Int, Negative, Positive };
+export { Int, Negative, NumberMax, NumberMin, Positive };

package/dist/clean/constraint/defaultConstraint/string.cjs

@@ -4,6 +4,8 @@ var base = require('../base.cjs');
 var base$1 = require('../../primitive/base.cjs');
 var email = require('../../../dataParser/parsers/string/checkers/email.cjs');
 var url = require('../../../dataParser/parsers/string/checkers/url.cjs');
+var min = require('../../../dataParser/parsers/string/checkers/min.cjs');
+var max = require('../../../dataParser/parsers/string/checkers/max.cjs');
 
 /**
  * {@include clean/Email/index.md}
@@ -13,6 +15,20 @@ const Email = base.createConstraint("email", base$1.String, email.checkerEmail()
  * {@include clean/Url/index.md}
  */
 const Url = base.createConstraint("url", base$1.String, url.checkerUrl());
+/**
+ * {@include clean/StringMin/index.md}
+ */
+function StringMin(value) {
+    return base.createConstraint(`string-min-${value}`, base$1.String, min.checkerStringMin(value));
+}
+/**
+ * {@include clean/StringMax/index.md}
+ */
+function StringMax(value) {
+    return base.createConstraint(`string-max-${value}`, base$1.String, max.checkerStringMax(value));
+}
 
 exports.Email = Email;
+exports.StringMax = StringMax;
+exports.StringMin = StringMin;
 exports.Url = Url;

package/dist/clean/constraint/defaultConstraint/string.d.ts

@@ -1,5 +1,6 @@
 import { type GetConstraint } from "../base";
 import * as DDataParser from "../../../dataParser";
+import { type OnlyLiteralNumber } from "../../../common";
 /**
  * Constraint handler that validates an email string.
  * 
@@ -58,3 +59,63 @@ export type Email = GetConstraint<typeof Email>;
  */
 export declare const Url: import("..").ConstraintHandler<"url", string, readonly [DDataParser.DataParserCheckerUrl]>;
 export type Url = GetConstraint<typeof Url>;
+/**
+ * Constraint factory that validates strings with a minimum length.
+ * 
+ * **Supported call styles:**
+ * - Classic: `StringMin(min)` -> returns a constraint handler
+ * 
+ * Creates a constraint handler for `C.String` that enforces a length greater than or equal to `min`. Use it to validate inputs and to constrain NewTypes with a minimum length requirement.
+ * 
+ * ```ts
+ * const UsernameMin = C.StringMin(3);
+ * 
+ * const result = UsernameMin.create("Ada");
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.Right<"createConstrainedType", C.ConstrainedType<"string-min-3", "Ada">>
+ * }
+ * 
+ * const username = UsernameMin.createOrThrow("Eve");
+ * // username: C.ConstrainedType<"string-min-3", "Eve">
+ * 
+ * UsernameMin.is(username); // type guard
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
+export declare function StringMin<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`string-min-${GenericValue & OnlyLiteralNumber<GenericValue>}`, string, readonly [DDataParser.DataParserCheckerStringMin]>;
+export type StringMin<GenericValue extends number> = GetConstraint<ReturnType<typeof StringMin<GenericValue>>>;
+/**
+ * Constraint factory that validates strings with a maximum length.
+ * 
+ * **Supported call styles:**
+ * - Classic: `StringMax(max)` -> returns a constraint handler
+ * 
+ * Creates a constraint handler for `C.String` that enforces a length less than or equal to `max`. Use it to validate inputs and to constrain NewTypes with a maximum length requirement.
+ * 
+ * ```ts
+ * const TitleMax = C.StringMax(10);
+ * 
+ * const result = TitleMax.create("Hello");
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.Right<"createConstrainedType", C.ConstrainedType<"string-max-10", "Hello">>
+ * }
+ * 
+ * const title = TitleMax.createOrThrow("World");
+ * // title: C.ConstrainedType<"string-max-10", "World">
+ * 
+ * TitleMax.is(title); // type guard
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
+export declare function StringMax<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`string-max-${GenericValue & OnlyLiteralNumber<GenericValue>}`, string, readonly [DDataParser.DataParserCheckerStringMax]>;
+export type StringMax<GenericValue extends number> = GetConstraint<ReturnType<typeof StringMax<GenericValue>>>;

package/dist/clean/constraint/defaultConstraint/string.mjs

@@ -2,6 +2,8 @@ import { createConstraint } from '../base.mjs';
 import { String } from '../../primitive/base.mjs';
 import { checkerEmail } from '../../../dataParser/parsers/string/checkers/email.mjs';
 import { checkerUrl } from '../../../dataParser/parsers/string/checkers/url.mjs';
+import { checkerStringMin } from '../../../dataParser/parsers/string/checkers/min.mjs';
+import { checkerStringMax } from '../../../dataParser/parsers/string/checkers/max.mjs';
 
 /**
  * {@include clean/Email/index.md}
@@ -11,5 +13,17 @@ const Email = createConstraint("email", String, checkerEmail());
  * {@include clean/Url/index.md}
  */
 const Url = createConstraint("url", String, checkerUrl());
+/**
+ * {@include clean/StringMin/index.md}
+ */
+function StringMin(value) {
+    return createConstraint(`string-min-${value}`, String, checkerStringMin(value));
+}
+/**
+ * {@include clean/StringMax/index.md}
+ */
+function StringMax(value) {
+    return createConstraint(`string-max-${value}`, String, checkerStringMax(value));
+}
 
-export { Email, Url };
+export { Email, StringMax, StringMin, Url };

package/dist/clean/constraint/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./base";
 export * from "./defaultConstraint";
+export * from "./set";

package/dist/clean/constraint/set.cjs

@@ -0,0 +1,93 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var base = require('./base.cjs');
+var kind$1 = require('../../common/kind.cjs');
+var flatMap = require('../../array/flatMap.cjs');
+var coalescing = require('../../array/coalescing.cjs');
+var pipe = require('../../common/pipe.cjs');
+var map = require('../../array/map.cjs');
+var entry = require('../../object/entry.cjs');
+var errorKindNamespace = require('../../common/errorKindNamespace.cjs');
+var is = require('../../either/left/is.cjs');
+var unwrap = require('../../common/unwrap.cjs');
+var create = require('../../either/left/create.cjs');
+var create$1 = require('../../either/right/create.cjs');
+var wrapValue = require('../../common/wrapValue.cjs');
+var fromEntries = require('../../object/fromEntries.cjs');
+
+const constraintsSetHandlerKind = kind.createCleanKind("constraints-set-handler");
+class CreateConstraintsSetError extends kind$1.kindHeritage("create-constraint-set-error", errorKindNamespace.createErrorKind("create-constraint-set-error"), Error) {
+    data;
+    dataParserError;
+    constructor(data, dataParserError) {
+        super({}, ["Error when create constrained type with set."]);
+        this.data = data;
+        this.dataParserError = dataParserError;
+    }
+}
+/**
+ * {@include clean/createConstraintsSet/index.md}
+ */
+function createConstraintsSet(primitiveHandler, constraint) {
+    const constraints = coalescing.coalescing(constraint);
+    const checkers = flatMap.flatMap(constraints, ({ checkers }) => checkers);
+    const dataParserWithCheckers = primitiveHandler
+        .dataParser
+        .addChecker(...checkers);
+    const constraintKindValue = pipe.pipe(constraints, map.map(({ name }) => entry.entry(name, null)), fromEntries.fromEntries);
+    const wrappedConstraints = pipe.pipe(constraints, map.map((constrain) => entry.entry(constrain.name, constrain)), fromEntries.fromEntries);
+    function getConstraint(name) {
+        return wrappedConstraints[name];
+    }
+    function create$2(data) {
+        const result = dataParserWithCheckers.parse(unwrap.unwrap(data));
+        if (is.isLeft(result)) {
+            return create.left("createConstraintsSetError", unwrap.unwrap(result));
+        }
+        else if (base.constrainedTypeKind.has(data)) {
+            return create$1.right("createConstraintsSet", base.constrainedTypeKind.addTo(data, {
+                ...base.constrainedTypeKind.getValue(data),
+                ...constraintKindValue,
+            }));
+        }
+        else {
+            return create$1.right("createConstraintsSet", base.constrainedTypeKind.setTo(wrapValue.wrapValue(unwrap.unwrap(result)), constraintKindValue));
+        }
+    }
+    function createOrThrow(data) {
+        const result = create$2(data);
+        if (is.isLeft(result)) {
+            throw new CreateConstraintsSetError(data, unwrap.unwrap(result));
+        }
+        else {
+            return unwrap.unwrap(result);
+        }
+    }
+    function is$1(input) {
+        if (!base.constrainedTypeKind.has(input)) {
+            return false;
+        }
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
+        for (let index = 0; index < constraints.length; index++) {
+            if (!constraints[index].is(input)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return constraintsSetHandlerKind.setTo({
+        primitiveHandler,
+        constrains: constraints,
+        getConstraint,
+        create: create$2,
+        createOrThrow,
+        createWithUnknown: create$2,
+        createWithUnknownOrThrow: createOrThrow,
+        is: is$1,
+    });
+}
+
+exports.CreateConstraintsSetError = CreateConstraintsSetError;
+exports.constraintsSetHandlerKind = constraintsSetHandlerKind;
+exports.createConstraintsSet = createConstraintsSet;

package/dist/clean/constraint/set.d.ts

@@ -0,0 +1,144 @@
+import { type Kind, type WrappedValue, type UnionToIntersection } from "../..";
+import { type GetConstraint, type ConstraintHandler } from "../constraint";
+import { type Primitive, type EligiblePrimitive, type PrimitiveHandler } from "../primitive";
+import * as DEither from "../../either";
+import * as DArray from "../../array";
+import type * as DDataParser from "../../dataParser";
+export declare const constraintsSetHandlerKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsClean/constraints-set-handler", unknown>>;
+export interface ConstraintsSetHandler<GenericPrimitiveValue extends EligiblePrimitive = EligiblePrimitive, GenericConstrainsHandler extends readonly ConstraintHandler[] = readonly []> extends Kind<typeof constraintsSetHandlerKind.definition> {
+    /**
+     * The primitive handler used to validate and wrap values (e.g. `C.String`, `C.Number`).
+     * 
+     */
+    readonly primitiveHandler: PrimitiveHandler<GenericPrimitiveValue>;
+    /**
+     * The list of constraint handlers applied by this set.
+     * 
+     */
+    readonly constrains: GenericConstrainsHandler;
+    /**
+     * Creates a constrained value and returns an Either.
+     * 
+     * ```ts
+     * const result = UsernameConstraints.create("Ada");
+     * 
+     * if (E.isRight(result)) {
+     * 	// result: E.Right<"createConstraintsSet", C.Primitive<"Ada"> & C.GetConstraints<typeof UsernameConstraints>>
+     * }
+     * ```
+     * 
+     */
+    create<const GenericInput extends GenericPrimitiveValue>(data: GenericInput): (DEither.Right<"createConstraintsSet", (Primitive<GenericInput> & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>)> | DEither.Left<"createConstraintsSetError", DDataParser.DataParserError>);
+    create<GenericPrimitive extends Primitive<GenericPrimitiveValue>>(data: GenericPrimitive): (DEither.Right<"createConstraintsSet", (GenericPrimitive & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>)> | DEither.Left<"createConstraintsSetError", DDataParser.DataParserError>);
+    /**
+     * Creates a constrained value and throws on error. Works with raw values or primitives.
+     * 
+     * ```ts
+     * const value = UsernameConstraints.createOrThrow("Nova");
+     * // value: C.Primitive<"Nova"> & C.GetConstraints<typeof UsernameConstraints>
+     * 
+     * const primitive = C.String.createOrThrow("Kit");
+     * UsernameConstraints.create(primitive);
+     * ```
+     * 
+     */
+    createOrThrow<const GenericInput extends GenericPrimitiveValue>(data: GenericInput): (Primitive<GenericInput> & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>);
+    createOrThrow<GenericPrimitive extends Primitive<GenericPrimitiveValue>>(data: GenericPrimitive): (GenericPrimitive & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>);
+    /**
+     * Creates a constrained value from an unknown input and returns an Either.
+     * 
+     * ```ts
+     * const unknownValue: unknown = "Sam";
+     * const maybe = UsernameConstraints.createWithUnknown(unknownValue);
+     * ```
+     * 
+     */
+    createWithUnknown<GenericInput extends unknown>(data: GenericInput): (DEither.Right<"createConstraintsSet", (Primitive<GenericPrimitiveValue> & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>)> | DEither.Left<"createConstraintsSetError", DDataParser.DataParserError>);
+    /**
+     * Creates a constrained value from an unknown input and throws on error.
+     * 
+     * ```ts
+     * const strictValue = UsernameConstraints.createWithUnknownOrThrow(unknownValue);
+     * ```
+     * 
+     */
+    createWithUnknownOrThrow<GenericInput extends unknown>(data: GenericInput): (Primitive<GenericPrimitiveValue> & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>);
+    /**
+     * Checks if a value satisfies all constraints of the set (type guard).
+     * 
+     * ```ts
+     * UsernameConstraints.is(value); // type guard
+     * ```
+     * 
+     */
+    is<GenericInput extends WrappedValue>(input: GenericInput): input is Extract<GenericInput, (Primitive<GenericPrimitiveValue> & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>)>;
+    /**
+     * Returns a constraint handler by name from the constraints set.
+     * 
+     * ```ts
+     * const constraint = UsernameConstraints.getConstraint("string-max-16");
+     * constraint.createOrThrow("hello");
+     * ```
+     * 
+     */
+    getConstraint<GenericConstraintName extends GenericConstrainsHandler[number]["name"]>(name: GenericConstraintName): Extract<GenericConstrainsHandler[number], ConstraintHandler<GenericConstraintName>>;
+}
+declare const CreateConstraintsSetError_base: new (params: {
+    "@DuplojsUtilsError/create-constraint-set-error"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("../..").KindDefinition<"create-constraint-set-error", unknown>, unknown> & Kind<import("../..").KindDefinition<"@DuplojsUtilsError/create-constraint-set-error", unknown>, unknown>;
+export declare class CreateConstraintsSetError extends CreateConstraintsSetError_base {
+    data: unknown;
+    dataParserError: DDataParser.DataParserError;
+    constructor(data: unknown, dataParserError: DDataParser.DataParserError);
+}
+/**
+ * Creates a constraints set handler to apply multiple constraints to a primitive.
+ * 
+ * **Supported call styles:**
+ * - Classic: `createConstraintsSet(primitiveHandler, constraints)` -> returns a handler
+ * 
+ * A constraints set validates input with the primitive DataParser, applies all constraint checkers, and tags the value with each constraint name. Use it to compose multiple constraints once and reuse the handler.
+ * 
+ * ```ts
+ * const UsernameConstraints = C.createConstraintsSet(
+ * 	C.String,
+ * 	[C.StringMin(3), C.StringMax(16)],
+ * );
+ * 
+ * const result = UsernameConstraints.create("Ada");
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.Right<"createConstraintsSet", C.Primitive<"Ada"> & C.GetConstraints<typeof UsernameConstraints>>
+ * }
+ * 
+ * const value = UsernameConstraints.createOrThrow("Nova");
+ * // value: C.Primitive<"Nova"> & C.GetConstraints<typeof UsernameConstraints>
+ * 
+ * const primitive = C.String.createOrThrow("Kit");
+ * UsernameConstraints.create(primitive);
+ * 
+ * const unknownValue: unknown = "Sam";
+ * const maybe = UsernameConstraints.createWithUnknown(unknownValue);
+ * const strictValue = UsernameConstraints.createWithUnknownOrThrow(unknownValue);
+ * 
+ * UsernameConstraints.is(value); // type guard
+ * 
+ * const constraint = UsernameConstraints.getConstraint("string-max-16");
+ * constraint.createOrThrow("hello");
+ * ```
+ * 
+ * @remarks
+ * - You can pass a single constraint handler or a tuple of constraints.
+ * - The handler accepts both raw values and primitives.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
+export declare function createConstraintsSet<GenericPrimitiveValue extends EligiblePrimitive, const GenericConstrainHandler extends (ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>[]> | readonly [
+    ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>[]>,
+    ...ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>[]>[]
+]) = never>(primitiveHandler: PrimitiveHandler<GenericPrimitiveValue>, constraint: GenericConstrainHandler): ConstraintsSetHandler<GenericPrimitiveValue, DArray.ArrayCoalescing<GenericConstrainHandler>>;
+export type GetConstraints<GenericHandler extends ConstraintsSetHandler<string, readonly any[]>> = Extract<GenericHandler extends any ? UnionToIntersection<GenericHandler["constrains"][number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never> : never, any>;
+export {};

package/dist/clean/constraint/set.mjs

@@ -0,0 +1,89 @@
+import { createCleanKind } from '../kind.mjs';
+import { constrainedTypeKind } from './base.mjs';
+import { kindHeritage } from '../../common/kind.mjs';
+import { flatMap } from '../../array/flatMap.mjs';
+import { coalescing } from '../../array/coalescing.mjs';
+import { pipe } from '../../common/pipe.mjs';
+import { map } from '../../array/map.mjs';
+import { entry } from '../../object/entry.mjs';
+import { createErrorKind } from '../../common/errorKindNamespace.mjs';
+import { isLeft } from '../../either/left/is.mjs';
+import { unwrap } from '../../common/unwrap.mjs';
+import { left } from '../../either/left/create.mjs';
+import { right } from '../../either/right/create.mjs';
+import { wrapValue } from '../../common/wrapValue.mjs';
+import { fromEntries } from '../../object/fromEntries.mjs';
+
+const constraintsSetHandlerKind = createCleanKind("constraints-set-handler");
+class CreateConstraintsSetError extends kindHeritage("create-constraint-set-error", createErrorKind("create-constraint-set-error"), Error) {
+    data;
+    dataParserError;
+    constructor(data, dataParserError) {
+        super({}, ["Error when create constrained type with set."]);
+        this.data = data;
+        this.dataParserError = dataParserError;
+    }
+}
+/**
+ * {@include clean/createConstraintsSet/index.md}
+ */
+function createConstraintsSet(primitiveHandler, constraint) {
+    const constraints = coalescing(constraint);
+    const checkers = flatMap(constraints, ({ checkers }) => checkers);
+    const dataParserWithCheckers = primitiveHandler
+        .dataParser
+        .addChecker(...checkers);
+    const constraintKindValue = pipe(constraints, map(({ name }) => entry(name, null)), fromEntries);
+    const wrappedConstraints = pipe(constraints, map((constrain) => entry(constrain.name, constrain)), fromEntries);
+    function getConstraint(name) {
+        return wrappedConstraints[name];
+    }
+    function create(data) {
+        const result = dataParserWithCheckers.parse(unwrap(data));
+        if (isLeft(result)) {
+            return left("createConstraintsSetError", unwrap(result));
+        }
+        else if (constrainedTypeKind.has(data)) {
+            return right("createConstraintsSet", constrainedTypeKind.addTo(data, {
+                ...constrainedTypeKind.getValue(data),
+                ...constraintKindValue,
+            }));
+        }
+        else {
+            return right("createConstraintsSet", constrainedTypeKind.setTo(wrapValue(unwrap(result)), constraintKindValue));
+        }
+    }
+    function createOrThrow(data) {
+        const result = create(data);
+        if (isLeft(result)) {
+            throw new CreateConstraintsSetError(data, unwrap(result));
+        }
+        else {
+            return unwrap(result);
+        }
+    }
+    function is(input) {
+        if (!constrainedTypeKind.has(input)) {
+            return false;
+        }
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
+        for (let index = 0; index < constraints.length; index++) {
+            if (!constraints[index].is(input)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return constraintsSetHandlerKind.setTo({
+        primitiveHandler,
+        constrains: constraints,
+        getConstraint,
+        create,
+        createOrThrow,
+        createWithUnknown: create,
+        createWithUnknownOrThrow: createOrThrow,
+        is,
+    });
+}
+
+export { CreateConstraintsSetError, constraintsSetHandlerKind, createConstraintsSet };

package/dist/clean/index.cjs

@@ -10,6 +10,7 @@ var unwrapEntity = require('./unwrapEntity.cjs');
 var base = require('./constraint/base.cjs');
 var number = require('./constraint/defaultConstraint/number.cjs');
 var string = require('./constraint/defaultConstraint/string.cjs');
+var set = require('./constraint/set.cjs');
 var base$1 = require('./primitive/base.cjs');
 var equal = require('./primitive/operations/equal.cjs');
 var add = require('./primitive/operations/number/add.cjs');
@@ -63,9 +64,16 @@ exports.constraintHandlerKind = base.constraintHandlerKind;
 exports.createConstraint = base.createConstraint;
 exports.Int = number.Int;
 exports.Negative = number.Negative;
+exports.NumberMax = number.NumberMax;
+exports.NumberMin = number.NumberMin;
 exports.Positive = number.Positive;
 exports.Email = string.Email;
+exports.StringMax = string.StringMax;
+exports.StringMin = string.StringMin;
 exports.Url = string.Url;
+exports.CreateConstraintsSetError = set.CreateConstraintsSetError;
+exports.constraintsSetHandlerKind = set.constraintsSetHandlerKind;
+exports.createConstraintsSet = set.createConstraintsSet;
 exports.BigInt = base$1.BigInt;
 exports.Boolean = base$1.Boolean;
 exports.CreatePrimitiveError = base$1.CreatePrimitiveError;

package/dist/clean/index.mjs

@@ -6,8 +6,9 @@ export { createUseCase, useCaseHandlerKind, useCaseInstances } from './useCase.m
 export { createFlag, flagKind } from './flag.mjs';
 export { unwrapEntity } from './unwrapEntity.mjs';
 export { CreateConstrainedTypeError, constrainedTypeKind, constraintHandlerKind, createConstraint } from './constraint/base.mjs';
-export { Int, Negative, Positive } from './constraint/defaultConstraint/number.mjs';
-export { Email, Url } from './constraint/defaultConstraint/string.mjs';
+export { Int, Negative, NumberMax, NumberMin, Positive } from './constraint/defaultConstraint/number.mjs';
+export { Email, StringMax, StringMin, Url } from './constraint/defaultConstraint/string.mjs';
+export { CreateConstraintsSetError, constraintsSetHandlerKind, createConstraintsSet } from './constraint/set.mjs';
 export { BigInt, Boolean, CreatePrimitiveError, Date, Number, String, Time, primitiveHandlerKind } from './primitive/base.mjs';
 export { equal } from './primitive/operations/equal.mjs';
 export { add } from './primitive/operations/number/add.mjs';

package/dist/clean/newType.cjs

@@ -1,7 +1,6 @@
 'use strict';
 
 var kind = require('./kind.cjs');
-var base = require('./constraint/base.cjs');
 var kind$1 = require('../common/kind.cjs');
 var flatMap = require('../array/flatMap.cjs');
 var coalescing = require('../array/coalescing.cjs');
@@ -12,6 +11,7 @@ var errorKindNamespace = require('../common/errorKindNamespace.cjs');
 var is = require('../either/left/is.cjs');
 var unwrap = require('../common/unwrap.cjs');
 var create = require('../either/left/create.cjs');
+var base = require('./constraint/base.cjs');
 var create$1 = require('../either/right/create.cjs');
 var wrapValue = require('../common/wrapValue.cjs');
 var fromEntries = require('../object/fromEntries.cjs');
@@ -33,12 +33,16 @@ class CreateNewTypeError extends kind$1.kindHeritage("create-new-type-error", er
  * {@include clean/createNewType/index.md}
  */
 function createNewType(name, dataParser, constraint) {
-    const constrains = coalescing.coalescing(constraint ?? []);
-    const checkers = flatMap.flatMap(constrains, ({ checkers }) => checkers);
+    const constraints = coalescing.coalescing(constraint ?? []);
+    const checkers = flatMap.flatMap(constraints, ({ checkers }) => checkers);
     const dataParserWithCheckers = constraint
         ? dataParser.addChecker(...checkers)
         : dataParser;
-    const constraintKindValue = pipe.pipe(constrains, map.map(({ name }) => entry.entry(name, null)), fromEntries.fromEntries);
+    const constraintKindValue = pipe.pipe(constraints, map.map(({ name }) => entry.entry(name, null)), fromEntries.fromEntries);
+    const wrappedConstraints = pipe.pipe(constraints, map.map((constrain) => entry.entry(constrain.name, constrain)), fromEntries.fromEntries);
+    function getConstraint(name) {
+        return wrappedConstraints[name];
+    }
     function create$2(data) {
         const result = dataParserWithCheckers.parse(unwrap.unwrap(data));
         if (is.isLeft(result)) {
@@ -69,8 +73,8 @@ function createNewType(name, dataParser, constraint) {
             return false;
         }
         // eslint-disable-next-line @typescript-eslint/prefer-for-of
-        for (let index = 0; index < constrains.length; index++) {
-            if (!constrains[index].is(input)) {
+        for (let index = 0; index < constraints.length; index++) {
+            if (!constraints[index].is(input)) {
                 return false;
             }
         }
@@ -79,7 +83,8 @@ function createNewType(name, dataParser, constraint) {
     return newTypeHandlerKind.setTo({
         name,
         dataParser: dataParserWithCheckers,
-        constrains,
+        constrains: constraints,
+        getConstraint,
         create: create$2,
         createOrThrow,
         createWithUnknown: create$2,

package/dist/clean/newType.d.ts

@@ -6,11 +6,11 @@ import * as DArray from "../array";
 import type * as DDataParser from "../dataParser";
 import { type DataParserContainTransform } from "./types";
 export declare const newTypeKind: import("..").KindHandler<import("..").KindDefinition<"@DuplojsUtilsClean/new-type", string>>;
-type _NewType<GenericName extends string, GenericValue extends unknown, GenericConstrainName extends string> = (Kind<typeof newTypeKind.definition, GenericName> & Kind<typeof constrainedTypeKind.definition, Record<GenericConstrainName, unknown>> & WrappedValue<GenericValue>);
-export interface NewType<GenericName extends string = string, GenericValue extends unknown = unknown, GenericConstrainName extends string = never> extends _NewType<GenericName, GenericValue, GenericConstrainName> {
+type _NewType<GenericName extends string, GenericValue extends unknown, GenericConstraintsName extends string> = (Kind<typeof newTypeKind.definition, GenericName> & Kind<typeof constrainedTypeKind.definition, Record<GenericConstraintsName, unknown>> & WrappedValue<GenericValue>);
+export interface NewType<GenericName extends string = string, GenericValue extends unknown = unknown, GenericConstraintsName extends string = never> extends _NewType<GenericName, GenericValue, GenericConstraintsName> {
 }
 export declare const newTypeHandlerKind: import("..").KindHandler<import("..").KindDefinition<"@DuplojsUtilsClean/new-type-handler", unknown>>;
-export interface NewTypeHandler<GenericName extends string = string, GenericValue extends unknown = unknown, GenericConstrainHandler extends readonly ConstraintHandler[] = readonly []> extends Kind<typeof newTypeHandlerKind.definition> {
+export interface NewTypeHandler<GenericName extends string = string, GenericValue extends unknown = unknown, GenericConstraintsHandler extends readonly ConstraintHandler[] = readonly []> extends Kind<typeof newTypeHandlerKind.definition> {
     /**
      * The NewType name used as the brand (for example "userId").
      * 
@@ -25,7 +25,7 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * The list of constraints applied to this NewType.
      * 
      */
-    readonly constrains: GenericConstrainHandler;
+    readonly constrains: GenericConstraintsHandler;
     /**
      * Creates a NewType value and returns an Either.
      * 
@@ -34,8 +34,8 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * ```
      * 
      */
-    create<const GenericData extends GenericValue>(data: GenericData): (DEither.Right<"createNewType", NewType<GenericName, GenericData, GenericConstrainHandler[number]["name"]>> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
-    create<GenericPrimitive extends Primitive<Extract<GenericValue, EligiblePrimitive>>>(data: GenericPrimitive): (DEither.Right<"createNewType", (GenericPrimitive & NewType<GenericName, Unwrap<GenericPrimitive>, GenericConstrainHandler[number]["name"]>)> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
+    create<const GenericInput extends GenericValue>(data: GenericInput): (DEither.Right<"createNewType", NewType<GenericName, GenericInput, GenericConstraintsHandler[number]["name"]>> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
+    create<GenericPrimitive extends Primitive<Extract<GenericValue, EligiblePrimitive>>>(data: GenericPrimitive): (DEither.Right<"createNewType", (GenericPrimitive & NewType<GenericName, Unwrap<GenericPrimitive>, GenericConstraintsHandler[number]["name"]>)> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
     /**
      * Creates a NewType value and throws on error. Works with raw values or primitives.
      * 
@@ -50,8 +50,8 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * ```
      * 
      */
-    createOrThrow<const GenericData extends GenericValue>(data: GenericData): NewType<GenericName, GenericData, GenericConstrainHandler[number]["name"]>;
-    createOrThrow<GenericPrimitive extends Primitive<Extract<GenericValue, EligiblePrimitive>>>(data: GenericPrimitive): (GenericPrimitive & NewType<GenericName, Unwrap<GenericPrimitive>, GenericConstrainHandler[number]["name"]>);
+    createOrThrow<const GenericData extends GenericValue>(data: GenericData): NewType<GenericName, GenericData, GenericConstraintsHandler[number]["name"]>;
+    createOrThrow<GenericPrimitive extends Primitive<Extract<GenericValue, EligiblePrimitive>>>(data: GenericPrimitive): (GenericPrimitive & NewType<GenericName, Unwrap<GenericPrimitive>, GenericConstraintsHandler[number]["name"]>);
     /**
      * Creates a NewType value from an unknown input and returns an Either.
      * 
@@ -65,7 +65,7 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * ```
      * 
      */
-    createWithUnknown<GenericData extends unknown>(data: GenericData): (DEither.Right<"createNewType", NewType<GenericName, GenericValue, GenericConstrainHandler[number]["name"]>> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
+    createWithUnknown<GenericInput extends unknown>(data: GenericInput): (DEither.Right<"createNewType", NewType<GenericName, GenericValue, GenericConstraintsHandler[number]["name"]>> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
     /**
      * Creates a NewType value from an unknown input and throws on error.
      * 
@@ -74,7 +74,7 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * ```
      * 
      */
-    createWithUnknownOrThrow<GenericData extends unknown>(data: GenericData): NewType<GenericName, GenericValue, GenericConstrainHandler[number]["name"]>;
+    createWithUnknownOrThrow<GenericInput extends unknown>(data: GenericInput): NewType<GenericName, GenericValue, GenericConstraintsHandler[number]["name"]>;
     /**
      * Checks if a value is a NewType of this handler (type guard).
      * 
@@ -83,7 +83,17 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * ```
      * 
      */
-    is<GenericInput extends WrappedValue>(input: GenericInput): input is Extract<GenericInput, NewType<GenericName, GenericValue, GenericConstrainHandler[number]["name"]>>;
+    is<GenericInput extends WrappedValue>(input: GenericInput): input is Extract<GenericInput, NewType<GenericName, GenericValue, GenericConstraintsHandler[number]["name"]>>;
+    /**
+     * Returns a constraint handler by name from the NewType constraints list.
+     * 
+     * ```ts
+     * const constraint = UserId.getConstraint("positive");
+     * constraint.createOrThrow(1);
+     * ```
+     * 
+     */
+    getConstraint<GenericConstraintName extends GenericConstraintsHandler[number]["name"]>(name: GenericConstraintName): Extract<GenericConstraintsHandler[number], ConstraintHandler<GenericConstraintName>>;
 }
 declare const CreateNewTypeError_base: new (params: {
     "@DuplojsUtilsError/create-new-type-error"?: unknown;
@@ -137,9 +147,9 @@ export declare class CreateNewTypeError extends CreateNewTypeError_base {
  * @namespace C
  * 
  */
-export declare function createNewType<GenericName extends string, GenericDataParser extends DDataParser.DataParser, const GenericConstrainHandler extends (ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, DDataParser.Output<GenericDataParser>>[]> | readonly [
+export declare function createNewType<GenericName extends string, GenericDataParser extends DDataParser.DataParser, const GenericConstraintsHandler extends (ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, DDataParser.Output<GenericDataParser>>[]> | readonly [
     ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, DDataParser.Output<GenericDataParser>>[]>,
     ...ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, DDataParser.Output<GenericDataParser>>[]>[]
-]) = never>(name: GenericName, dataParser: GenericDataParser & DataParserContainTransform<GenericDataParser>, constraint?: GenericConstrainHandler): NewTypeHandler<GenericName, DeepReadonly<DDataParser.Output<GenericDataParser>>, DArray.ArrayCoalescing<NeverCoalescing<GenericConstrainHandler, readonly []>>>;
+]) = never>(name: GenericName, dataParser: GenericDataParser & DataParserContainTransform<GenericDataParser>, constraint?: GenericConstraintsHandler): NewTypeHandler<GenericName, DeepReadonly<DDataParser.Output<GenericDataParser>>, DArray.ArrayCoalescing<NeverCoalescing<GenericConstraintsHandler, readonly []>>>;
 export type GetNewType<GenericHandler extends NewTypeHandler<string, unknown, readonly any[]>> = Extract<GenericHandler extends any ? NewType<GenericHandler["name"], DDataParser.Output<GenericHandler["dataParser"]>, GenericHandler["constrains"][number]["name"]> : never, any>;
 export {};

package/dist/clean/newType.mjs

@@ -1,5 +1,4 @@
 import { createCleanKind } from './kind.mjs';
-import { constrainedTypeKind } from './constraint/base.mjs';
 import { kindHeritage } from '../common/kind.mjs';
 import { flatMap } from '../array/flatMap.mjs';
 import { coalescing } from '../array/coalescing.mjs';
@@ -10,6 +9,7 @@ import { createErrorKind } from '../common/errorKindNamespace.mjs';
 import { isLeft } from '../either/left/is.mjs';
 import { unwrap } from '../common/unwrap.mjs';
 import { left } from '../either/left/create.mjs';
+import { constrainedTypeKind } from './constraint/base.mjs';
 import { right } from '../either/right/create.mjs';
 import { wrapValue } from '../common/wrapValue.mjs';
 import { fromEntries } from '../object/fromEntries.mjs';
@@ -31,12 +31,16 @@ class CreateNewTypeError extends kindHeritage("create-new-type-error", createErr
  * {@include clean/createNewType/index.md}
  */
 function createNewType(name, dataParser, constraint) {
-    const constrains = coalescing(constraint ?? []);
-    const checkers = flatMap(constrains, ({ checkers }) => checkers);
+    const constraints = coalescing(constraint ?? []);
+    const checkers = flatMap(constraints, ({ checkers }) => checkers);
     const dataParserWithCheckers = constraint
         ? dataParser.addChecker(...checkers)
         : dataParser;
-    const constraintKindValue = pipe(constrains, map(({ name }) => entry(name, null)), fromEntries);
+    const constraintKindValue = pipe(constraints, map(({ name }) => entry(name, null)), fromEntries);
+    const wrappedConstraints = pipe(constraints, map((constrain) => entry(constrain.name, constrain)), fromEntries);
+    function getConstraint(name) {
+        return wrappedConstraints[name];
+    }
     function create(data) {
         const result = dataParserWithCheckers.parse(unwrap(data));
         if (isLeft(result)) {
@@ -67,8 +71,8 @@ function createNewType(name, dataParser, constraint) {
             return false;
         }
         // eslint-disable-next-line @typescript-eslint/prefer-for-of
-        for (let index = 0; index < constrains.length; index++) {
-            if (!constrains[index].is(input)) {
+        for (let index = 0; index < constraints.length; index++) {
+            if (!constraints[index].is(input)) {
                 return false;
             }
         }
@@ -77,7 +81,8 @@ function createNewType(name, dataParser, constraint) {
     return newTypeHandlerKind.setTo({
         name,
         dataParser: dataParserWithCheckers,
-        constrains,
+        constrains: constraints,
+        getConstraint,
         create,
         createOrThrow,
         createWithUnknown: create,

package/dist/common/index.d.ts

@@ -42,6 +42,7 @@ export * from "./toJSON";
 export * from "./toTransform";
 export * from "./toWrappedValue";
 export * from "./unwrap";
+export * from "./unwrapGroup";
 export * from "./asyncLoop";
 export * from "./asyncRetry";
 export * from "./wrapValue";
@@ -59,6 +60,7 @@ export * from "./or";
 export * from "./whenElse";
 export * from "./justReturn";
 export * from "./memo";
+export * from "./memoPromise";
 export * from "./instanceOf";
 export * from "./globalStore";
 export * from "./builder";

package/dist/common/memo.d.ts

@@ -1,13 +1,12 @@
-import { type AnyValue } from "./types";
 export interface Memoized<GenericValue extends unknown> {
     readonly value: GenericValue;
 }
 /**
- * The memo() function evaluates a function only once then memorizes the result. Subsequent calls return the same value without recalculation.
+ * The memo() function evaluates a function only once then memorizes the result. The first access to `value` triggers the evaluation.
  * 
- * Signature: `memo(theFunction)` → returns a value
+ * Signature: `memo(theFunction)` → returns a memoized object
  * 
- * The input value is not mutated.
+ * The input function is called only once.
  * 
  * ```ts
  * let calls = 0;
@@ -25,4 +24,4 @@ export interface Memoized<GenericValue extends unknown> {
  * @see https://utils.duplojs.dev/en/v1/api/common/memo
  * 
  */
-export declare function memo<GenericOutput extends AnyValue>(theFunction: () => GenericOutput): Memoized<GenericOutput>;
+export declare function memo<GenericOutput extends unknown>(theFunction: () => GenericOutput): Memoized<GenericOutput>;

package/dist/common/memoPromise.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+var externalPromise = require('./externalPromise.cjs');
+var forward = require('./forward.cjs');
+
+/**
+ * {@include common/memoPromise/index.md}
+ */
+function memoPromise(theFunction) {
+    let externalPromise$1 = forward.forward(undefined);
+    const payload = {
+        get value() {
+            if (externalPromise$1) {
+                return externalPromise$1.promise;
+            }
+            externalPromise$1 = externalPromise.createExternalPromise();
+            const { resolve, reject } = externalPromise$1;
+            const promise = theFunction();
+            void (promise instanceof Promise
+                ? promise
+                : Promise.resolve(promise))
+                .then((result) => {
+                Object.defineProperty(payload, "value", {
+                    value: result,
+                });
+                resolve(result);
+            })
+                .catch(reject);
+            return externalPromise$1.promise;
+        },
+    };
+    return payload;
+}
+
+exports.memoPromise = memoPromise;

package/dist/common/memoPromise.d.ts

@@ -0,0 +1,25 @@
+import { type MaybePromise } from "./types";
+export interface MemoizedPromise<GenericValue extends unknown> {
+    readonly value: MaybePromise<GenericValue>;
+}
+/**
+ * The memoPromise() function lazily evaluates a function that returns a value or a promise, then memoizes the resolved result.
+ * 
+ * Signature: `memoPromise(theFunction)` → returns a memoized object
+ * 
+ * The input function is called only once, and concurrent reads share the same promise.
+ * 
+ * ```ts
+ * const memoizedValue = memoPromise(() => "ready");
+ * const first = await memoizedValue.value;
+ * // "ready"
+ * 
+ * const memoizedPromise = memoPromise(() => Promise.resolve("ok"));
+ * const okValue = await memoizedPromise.value;
+ * // "ok"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/memoPromise
+ * 
+ */
+export declare function memoPromise<GenericOutput extends unknown>(theFunction: () => MaybePromise<GenericOutput>): MemoizedPromise<GenericOutput>;

package/dist/common/memoPromise.mjs

@@ -0,0 +1,33 @@
+import { createExternalPromise } from './externalPromise.mjs';
+import { forward } from './forward.mjs';
+
+/**
+ * {@include common/memoPromise/index.md}
+ */
+function memoPromise(theFunction) {
+    let externalPromise = forward(undefined);
+    const payload = {
+        get value() {
+            if (externalPromise) {
+                return externalPromise.promise;
+            }
+            externalPromise = createExternalPromise();
+            const { resolve, reject } = externalPromise;
+            const promise = theFunction();
+            void (promise instanceof Promise
+                ? promise
+                : Promise.resolve(promise))
+                .then((result) => {
+                Object.defineProperty(payload, "value", {
+                    value: result,
+                });
+                resolve(result);
+            })
+                .catch(reject);
+            return externalPromise.promise;
+        },
+    };
+    return payload;
+}
+
+export { memoPromise };

package/dist/common/unwrapGroup.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var unwrap = require('./unwrap.cjs');
+
+/**
+ * {@include common/unwrapGroup/index.md}
+ */
+function unwrapGroup(group) {
+    const result = {};
+    for (const key in group) {
+        result[key] = unwrap.unwrap(group[key]);
+    }
+    return result;
+}
+
+exports.unwrapGroup = unwrapGroup;

package/dist/common/unwrapGroup.d.ts

@@ -0,0 +1,36 @@
+import { type SimplifyTopLevel } from "./types";
+import { type Unwrap } from "./unwrap";
+type ComputeResult<GenericGroup extends Record<string, unknown>> = SimplifyTopLevel<{
+    [Prop in keyof GenericGroup]: Unwrap<GenericGroup[Prop]>;
+}>;
+/**
+ * The unwrapGroup() function unwraps every value of an object using unwrap(), returning a new object with the same keys.
+ * 
+ * Signature: `unwrapGroup(group)` → returns an object
+ * 
+ * The input object is not mutated.
+ * 
+ * ```ts
+ * const first = unwrapGroup({
+ * 	value: wrapValue(1),
+ * });
+ * // { value: 1 }
+ * 
+ * const mixed = unwrapGroup({
+ * 	count: wrapValue(2),
+ * 	label: "ok",
+ * });
+ * // { count: 2, label: "ok" }
+ * 
+ * const user = unwrapGroup({
+ * 	firstName: wrapValue("Ada"),
+ * 	lastName: "Lovelace",
+ * });
+ * // { firstName: "Ada", lastName: "Lovelace" }
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/unwrapGroup
+ * 
+ */
+export declare function unwrapGroup<const GenericGroup extends Record<string, unknown>>(group: GenericGroup): ComputeResult<GenericGroup>;
+export {};

package/dist/common/unwrapGroup.mjs

@@ -0,0 +1,14 @@
+import { unwrap } from './unwrap.mjs';
+
+/**
+ * {@include common/unwrapGroup/index.md}
+ */
+function unwrapGroup(group) {
+    const result = {};
+    for (const key in group) {
+        result[key] = unwrap(group[key]);
+    }
+    return result;
+}
+
+export { unwrapGroup };

package/dist/index.cjs

@@ -31,6 +31,7 @@ var toJSON = require('./common/toJSON.cjs');
 var toTransform = require('./common/toTransform.cjs');
 var toWrappedValue = require('./common/toWrappedValue.cjs');
 var unwrap = require('./common/unwrap.cjs');
+var unwrapGroup = require('./common/unwrapGroup.cjs');
 var asyncLoop = require('./common/asyncLoop.cjs');
 var asyncRetry = require('./common/asyncRetry.cjs');
 var wrapValue = require('./common/wrapValue.cjs');
@@ -48,6 +49,7 @@ var or = require('./common/or.cjs');
 var whenElse = require('./common/whenElse.cjs');
 var justReturn = require('./common/justReturn.cjs');
 var memo = require('./common/memo.cjs');
+var memoPromise = require('./common/memoPromise.cjs');
 var instanceOf = require('./common/instanceOf.cjs');
 var globalStore = require('./common/globalStore.cjs');
 var builder = require('./common/builder.cjs');
@@ -115,6 +117,7 @@ exports.toJSON = toJSON.toJSON;
 exports.toTransform = toTransform.toTransform;
 exports.toWrappedValue = toWrappedValue.toWrappedValue;
 exports.unwrap = unwrap.unwrap;
+exports.unwrapGroup = unwrapGroup.unwrapGroup;
 exports.asyncLoop = asyncLoop.asyncLoop;
 exports.createAsyncRetry = asyncRetry.createAsyncRetry;
 exports.useAsyncRetry = asyncRetry.useAsyncRetry;
@@ -136,6 +139,7 @@ exports.or = or.or;
 exports.whenElse = whenElse.whenElse;
 exports.justReturn = justReturn.justReturn;
 exports.memo = memo.memo;
+exports.memoPromise = memoPromise.memoPromise;
 exports.instanceOf = instanceOf.instanceOf;
 exports.createGlobalStore = globalStore.createGlobalStore;
 exports.MissingBuilderMethodsError = builder.MissingBuilderMethodsError;

package/dist/index.mjs

@@ -53,6 +53,7 @@ export { toJSON } from './common/toJSON.mjs';
 export { toTransform } from './common/toTransform.mjs';
 export { toWrappedValue } from './common/toWrappedValue.mjs';
 export { unwrap } from './common/unwrap.mjs';
+export { unwrapGroup } from './common/unwrapGroup.mjs';
 export { asyncLoop } from './common/asyncLoop.mjs';
 export { createAsyncRetry, useAsyncRetry } from './common/asyncRetry.mjs';
 export { isRuntimeWrappedValueKey, isWrappedValue, keyWrappedValue, wrapValue } from './common/wrapValue.mjs';
@@ -70,6 +71,7 @@ export { or } from './common/or.mjs';
 export { whenElse } from './common/whenElse.mjs';
 export { justReturn } from './common/justReturn.mjs';
 export { memo } from './common/memo.mjs';
+export { memoPromise } from './common/memoPromise.mjs';
 export { instanceOf } from './common/instanceOf.mjs';
 export { createGlobalStore } from './common/globalStore.mjs';
 export { MissingBuilderMethodsError, builderKind, createBuilder } from './common/builder.mjs';

package/dist/metadata.json

@@ -626,6 +626,15 @@
             },
             {
               "name": "index.d.ts"
+            },
+            {
+              "name": "set.cjs"
+            },
+            {
+              "name": "set.d.ts"
+            },
+            {
+              "name": "set.mjs"
             }
           ]
         },
@@ -1415,6 +1424,15 @@
         {
           "name": "memo.mjs"
         },
+        {
+          "name": "memoPromise.cjs"
+        },
+        {
+          "name": "memoPromise.d.ts"
+        },
+        {
+          "name": "memoPromise.mjs"
+        },
         {
           "name": "mimeType.cjs"
         },
@@ -1577,6 +1595,15 @@
         {
           "name": "unwrap.mjs"
         },
+        {
+          "name": "unwrapGroup.cjs"
+        },
+        {
+          "name": "unwrapGroup.d.ts"
+        },
+        {
+          "name": "unwrapGroup.mjs"
+        },
         {
           "name": "when.cjs"
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.4.50",
+  "version": "1.4.52",
   "author": {
     "name": "mathcovax",
     "url": "https://github.com/mathcovax"
@@ -27,8 +27,8 @@
     "test:tu:watch": "vitest --coverage --watch",
     "test:tu:update": "vitest --coverage --update",
     "test:types": "tsc -p tsconfig.test.json && npm -w docs run test:types",
-    "test:lint": "eslint",
-    "test:lint:fix": "eslint --fix",
+    "test:lint": "eslint --quiet",
+    "test:lint:fix": "eslint --fix --quiet",
     "prepare": "husky"
   },
   "sideEffects": false,