@duplojs/utils 1.5.5 → 1.5.7

package/dist/date/types/serializedTheTime.d.ts

@@ -1,5 +1,5 @@
 /**
- * Represents an immutable time value object (`TheTime`) stored in milliseconds.
+ * Represents an immutable signed time value object (`TheTime`) stored in milliseconds.
  * 
  * Signature: `TheTime` → immutable class-like value object
  * 
@@ -28,6 +28,7 @@
  * 
  * @remarks
  * - `TheTime` is not a `number`, but it behaves as an immutable numeric time value.
+ * - `TheTime` supports negative values and is not an absolute value by default.
  * - Date unit operators (`addMinutes`, `subtractDays`, etc.) target `TheDate`; `TheTime` is used as a normalized duration value.
  * - Use `D.serialize(theTime)` to convert to `SerializedTheTime`.
  * - Use `D.createTime(...)` / `D.createTimeOrThrow(...)` to construct instances.

package/dist/metadata.json

@@ -647,6 +647,38 @@
             }
           ]
         },
+        {
+          "name": "entity",
+          "files": [
+            {
+              "name": "index.cjs"
+            },
+            {
+              "name": "index.d.ts"
+            },
+            {
+              "name": "index.mjs"
+            },
+            {
+              "name": "property.cjs"
+            },
+            {
+              "name": "property.d.ts"
+            },
+            {
+              "name": "property.mjs"
+            },
+            {
+              "name": "unwrap.cjs"
+            },
+            {
+              "name": "unwrap.d.ts"
+            },
+            {
+              "name": "unwrap.mjs"
+            }
+          ]
+        },
         {
           "name": "primitive",
           "files": [
@@ -940,15 +972,6 @@
             }
           ]
         },
-        {
-          "name": "entity.cjs"
-        },
-        {
-          "name": "entity.d.ts"
-        },
-        {
-          "name": "entity.mjs"
-        },
         {
           "name": "flag.cjs"
         },
@@ -1003,15 +1026,6 @@
         {
           "name": "repository.mjs"
         },
-        {
-          "name": "unwrapEntity.cjs"
-        },
-        {
-          "name": "unwrapEntity.d.ts"
-        },
-        {
-          "name": "unwrapEntity.mjs"
-        },
         {
           "name": "useCase.cjs"
         },
@@ -3087,6 +3101,15 @@
         {
           "name": "closestTo.mjs"
         },
+        {
+          "name": "computeTime.cjs"
+        },
+        {
+          "name": "computeTime.d.ts"
+        },
+        {
+          "name": "computeTime.mjs"
+        },
         {
           "name": "constants.cjs"
         },
@@ -3159,6 +3182,15 @@
         {
           "name": "formatTime.mjs"
         },
+        {
+          "name": "getDifference.cjs"
+        },
+        {
+          "name": "getDifference.d.ts"
+        },
+        {
+          "name": "getDifference.mjs"
+        },
         {
           "name": "getTimezoneOffset.cjs"
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.5.5",
+  "version": "1.5.7",
   "author": {
     "name": "mathcovax",
     "url": "https://github.com/mathcovax"
@@ -114,7 +114,7 @@
     "@commitlint/config-conventional": "19.8.1",
     "@duplojs/dev-tools": "0.2.0",
     "@duplojs/eslint": "0.5.0",
-    "@rollup/plugin-typescript": "12.1.4",
+    "@rollup/plugin-typescript": "12.3.0",
     "@types/node": "24.3.0",
     "@vitest/coverage-istanbul": "3.2.4",
     "eslint": "9.34.0",

package/dist/clean/entity.cjs

@@ -1,145 +0,0 @@
-'use strict';
-
-var kind = require('./kind.cjs');
-var newType = require('./newType.cjs');
-var asserts = require('../common/asserts.cjs');
-var kind$1 = require('../common/kind.cjs');
-var pipe = require('../common/pipe.cjs');
-var map = require('../array/map.cjs');
-var toTuple = require('../array/toTuple.cjs');
-var first = require('../array/at/first.cjs');
-var innerPipe = require('../common/innerPipe.cjs');
-var when = require('../pattern/when.cjs');
-var isType = require('../common/isType.cjs');
-var exhaustive = require('../pattern/exhaustive.cjs');
-var when$1 = require('../common/when.cjs');
-var index = require('../dataParser/parsers/array/index.cjs');
-var min = require('../dataParser/parsers/array/checkers/min.cjs');
-var max = require('../dataParser/parsers/array/checkers/max.cjs');
-var nullable = require('../dataParser/parsers/nullable.cjs');
-var base = require('../dataParser/base.cjs');
-var last = require('../array/at/last.cjs');
-var entries = require('../object/entries.cjs');
-var forward = require('../common/forward.cjs');
-var errorKindNamespace = require('../common/errorKindNamespace.cjs');
-var fromEntries = require('../object/fromEntries.cjs');
-var entry = require('../object/entry.cjs');
-var transform = require('../dataParser/parsers/transform.cjs');
-var base$1 = require('./constraint/base.cjs');
-var wrapValue = require('../common/wrapValue.cjs');
-var minElements = require('../array/minElements.cjs');
-var union = require('../dataParser/parsers/union.cjs');
-var index$1 = require('../dataParser/parsers/object/index.cjs');
-var override = require('../common/override.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');
-
-const entityKind = kind.createCleanKind("entity");
-const entityHandlerKind = kind.createCleanKind("entity-handler");
-class CreateEntityError extends kind$1.kindHeritage("create-entity-error", errorKindNamespace.createErrorKind("create-entity-error"), Error) {
-    rawProperties;
-    dataParserError;
-    constructor(rawProperties, dataParserError) {
-        super({}, ["Error when create entity."]);
-        this.rawProperties = rawProperties;
-        this.dataParserError = dataParserError;
-    }
-}
-/**
- * {@include clean/createEntity/index.md}
- */
-function createEntity(name, getPropertiesDefinition) {
-    function theNew(properties) {
-        return entityKind.addTo(properties, name);
-    }
-    function simplePropertyDefinitionToDataParser(simplePropertyDefinition) {
-        const constraintKindValue = pipe.pipe(simplePropertyDefinition.constraints, map.map(({ name }) => entry.entry(name, null)), fromEntries.fromEntries);
-        return transform.transform(simplePropertyDefinition.dataParser, (value) => base$1.constrainedTypeKind.setTo(newType.newTypeKind.setTo(wrapValue.wrapValue(value), simplePropertyDefinition.name), constraintKindValue));
-    }
-    function unionPropertyDefinitionToDataParser(unionPropertyDefinition) {
-        return pipe.pipe(unionPropertyDefinition, map.map(simplePropertyDefinitionToDataParser), (options) => {
-            asserts.asserts(options, minElements.minElements(1));
-            return union.union(options);
-        });
-    }
-    const params = {
-        union: (...type) => ({ type }),
-        array: (definition, params) => (newType.newTypeHandlerKind.has(definition) || definition instanceof Array
-            ? {
-                type: definition,
-                inArray: params ?? true,
-            }
-            : {
-                ...definition,
-                inArray: params ?? true,
-            }),
-        nullable: (definition) => (newType.newTypeHandlerKind.has(definition) || definition instanceof Array
-            ? {
-                type: definition,
-                nullable: true,
-            }
-            : {
-                ...definition,
-                nullable: true,
-            }),
-    };
-    const propertiesDefinition = getPropertiesDefinition(params);
-    const mapDataParser = pipe.pipe(forward.forward(propertiesDefinition), entries.entries, map.map(toTuple.toTuple([
-        first.first,
-        innerPipe.innerPipe(last.last, when.when(newType.newTypeHandlerKind.has, simplePropertyDefinitionToDataParser), when.when(isType.isType("array"), unionPropertyDefinitionToDataParser), when.when(isType.isType("object"), (definition) => pipe.pipe(definition.type, when.when(newType.newTypeHandlerKind.has, simplePropertyDefinitionToDataParser), when.when(isType.isType("array"), unionPropertyDefinitionToDataParser), exhaustive.exhaustive, when$1.when(base.dataParserKind.has, innerPipe.innerPipe((dataParser) => {
-            if (definition.inArray) {
-                return pipe.pipe(index.array(dataParser), (dataParser) => typeof definition.inArray === "object"
-                    && definition.inArray.min !== undefined
-                    ? dataParser.addChecker(min.checkerArrayMin(definition.inArray.min))
-                    : dataParser, (dataParser) => typeof definition.inArray === "object"
-                    && definition.inArray.max !== undefined
-                    ? dataParser.addChecker(max.checkerArrayMax(definition.inArray.max))
-                    : dataParser);
-            }
-            return dataParser;
-        }, when$1.when(() => definition.nullable === true, nullable.nullable))))), exhaustive.exhaustive),
-    ])), fromEntries.fromEntries, index$1.object, (dataParser) => transform.transform(dataParser, (value) => entityKind.setTo(value, name)));
-    function map$1(rawProperties) {
-        const result = mapDataParser.parse(rawProperties);
-        if (is.isLeft(result)) {
-            return create.left("createEntityError", unwrap.unwrap(result));
-        }
-        return create$1.right("createEntity", unwrap.unwrap(result));
-    }
-    function mapOrThrow(rawProperties) {
-        const result = mapDataParser.parse(rawProperties);
-        if (is.isLeft(result)) {
-            throw new CreateEntityError(rawProperties, unwrap.unwrap(result));
-        }
-        return unwrap.unwrap(result);
-    }
-    function is$1(input) {
-        return entityKind.has(input) && entityKind.getValue(input) === name;
-    }
-    function update(entity, newProperties) {
-        const updatedEntity = {};
-        for (const key in propertiesDefinition) {
-            updatedEntity[key] = newProperties[key] !== undefined
-                ? newProperties[key]
-                : entity[key];
-        }
-        return entityKind.setTo(updatedEntity, name);
-    }
-    return pipe.pipe({
-        name,
-        propertiesDefinition,
-        mapDataParser,
-        new: theNew,
-        map: map$1,
-        mapOrThrow,
-        is: is$1,
-        update,
-    }, entityHandlerKind.setTo, createEntity.overrideHandler.apply);
-}
-createEntity.overrideHandler = override.createOverride("@duplojs/utils/clean/entity");
-
-exports.CreateEntityError = CreateEntityError;
-exports.createEntity = createEntity;
-exports.entityKind = entityKind;

package/dist/clean/entity.d.ts

@@ -1,234 +0,0 @@
-import { type SimplifyTopLevel, type Kind, type Unwrap, type IsEqual, type IsExtends, type Or, type NeverCoalescing, type RemoveKind } from "../common";
-import { type GetNewType, type NewTypeHandler } from "./newType";
-import * as DEither from "../either";
-import * as DDataParser from "../dataParser";
-import * as DObject from "../object";
-import * as DArray from "../array";
-export type EntitySimplePropertyDefinition = NewTypeHandler<string, unknown, readonly any[]>;
-export type EntityUnionPropertyDefinition = readonly [
-    EntitySimplePropertyDefinition,
-    ...EntitySimplePropertyDefinition[]
-];
-export interface EntityAdvancedArrayPropertyDefinition {
-    min?: number;
-    max?: number;
-}
-export interface EntityAdvancedPropertyDefinition {
-    type: (EntitySimplePropertyDefinition | EntityUnionPropertyDefinition);
-    nullable?: true;
-    inArray?: true | EntityAdvancedArrayPropertyDefinition;
-}
-export type EntityPropertyDefinition = (EntitySimplePropertyDefinition | EntityUnionPropertyDefinition | EntityAdvancedPropertyDefinition);
-export type EntityPropertiesDefinition = Readonly<Record<string, EntityPropertyDefinition>>;
-export type EntityProperties<GenericPropertiesDefinition extends EntityPropertiesDefinition = EntityPropertiesDefinition> = SimplifyTopLevel<{
-    readonly [Prop in keyof GenericPropertiesDefinition]: (GenericPropertiesDefinition[Prop] extends EntitySimplePropertyDefinition ? GetNewType<GenericPropertiesDefinition[Prop]> : GenericPropertiesDefinition[Prop] extends EntityUnionPropertyDefinition ? GetNewType<GenericPropertiesDefinition[Prop][number]> : GenericPropertiesDefinition[Prop] extends EntityAdvancedPropertyDefinition ? GetNewType<GenericPropertiesDefinition[Prop]["type"] extends EntityUnionPropertyDefinition ? GenericPropertiesDefinition[Prop]["type"][number] : GenericPropertiesDefinition[Prop]["type"] extends EntitySimplePropertyDefinition ? GenericPropertiesDefinition[Prop]["type"] : never> extends infer InferredValue ? (IsEqual<GenericPropertiesDefinition[Prop]["inArray"], true> extends true ? readonly InferredValue[] : GenericPropertiesDefinition[Prop]["inArray"] extends object ? GenericPropertiesDefinition[Prop]["inArray"]["min"] extends number ? readonly [
-        ...DArray.CreateTuple<InferredValue, GenericPropertiesDefinition[Prop]["inArray"]["min"]>,
-        ...InferredValue[]
-    ] : readonly InferredValue[] : InferredValue) extends infer InferredValueWithArray ? IsEqual<GenericPropertiesDefinition[Prop]["nullable"], true> extends true ? InferredValueWithArray | null : InferredValueWithArray : never : never : unknown);
-}>;
-export type EntityRawProperties<GenericPropertiesDefinition extends EntityPropertiesDefinition = EntityPropertiesDefinition> = SimplifyTopLevel<{
-    readonly [Prop in keyof GenericPropertiesDefinition]: (GenericPropertiesDefinition[Prop] extends EntitySimplePropertyDefinition ? Unwrap<GetNewType<GenericPropertiesDefinition[Prop]>> : GenericPropertiesDefinition[Prop] extends EntityUnionPropertyDefinition ? Unwrap<GetNewType<GenericPropertiesDefinition[Prop][number]>> : GenericPropertiesDefinition[Prop] extends EntityAdvancedPropertyDefinition ? Unwrap<GetNewType<GenericPropertiesDefinition[Prop]["type"] extends EntityUnionPropertyDefinition ? GenericPropertiesDefinition[Prop]["type"][number] : GenericPropertiesDefinition[Prop]["type"] extends EntitySimplePropertyDefinition ? GenericPropertiesDefinition[Prop]["type"] : never>> extends infer InferredValue ? (IsEqual<GenericPropertiesDefinition[Prop]["inArray"], true> extends true ? readonly InferredValue[] : GenericPropertiesDefinition[Prop]["inArray"] extends object ? GenericPropertiesDefinition[Prop]["inArray"]["min"] extends number ? readonly [
-        ...DArray.CreateTuple<InferredValue, GenericPropertiesDefinition[Prop]["inArray"]["min"]>,
-        ...InferredValue[]
-    ] : readonly InferredValue[] : InferredValue) extends infer InferredValueWithArray ? IsEqual<GenericPropertiesDefinition[Prop]["nullable"], true> extends true ? InferredValueWithArray | null : InferredValueWithArray : never : never : unknown);
-}>;
-type GetInputFromNewTypeHandler<GenericNewTypeHandler extends NewTypeHandler> = GenericNewTypeHandler extends NewTypeHandler<any, infer InferredValue, any, infer InferredInput> ? IsEqual<InferredInput, never> extends true ? InferredValue : InferredInput : never;
-export type PropertiesToMapOfEntity<GenericPropertiesDefinition extends EntityPropertiesDefinition = EntityPropertiesDefinition> = SimplifyTopLevel<{
-    readonly [Prop in keyof GenericPropertiesDefinition]: (GenericPropertiesDefinition[Prop] extends EntitySimplePropertyDefinition ? GetInputFromNewTypeHandler<GenericPropertiesDefinition[Prop]> : GenericPropertiesDefinition[Prop] extends EntityUnionPropertyDefinition ? GetInputFromNewTypeHandler<GenericPropertiesDefinition[Prop][number]> : GenericPropertiesDefinition[Prop] extends EntityAdvancedPropertyDefinition ? GetInputFromNewTypeHandler<GenericPropertiesDefinition[Prop]["type"] extends EntityUnionPropertyDefinition ? GenericPropertiesDefinition[Prop]["type"][number] : GenericPropertiesDefinition[Prop]["type"] extends EntitySimplePropertyDefinition ? GenericPropertiesDefinition[Prop]["type"] : never> extends infer InferredValue ? (Or<[
-        IsEqual<GenericPropertiesDefinition[Prop]["inArray"], true>,
-        IsExtends<GenericPropertiesDefinition[Prop]["inArray"], object>
-    ]> extends true ? readonly InferredValue[] : InferredValue) extends infer InferredValueWithArray ? IsEqual<GenericPropertiesDefinition[Prop]["nullable"], true> extends true ? InferredValueWithArray | null : InferredValueWithArray : never : never : never);
-}>;
-export declare const entityKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsClean/entity", string>>;
-export interface Entity<GenericName extends string = string> extends Kind<typeof entityKind.definition, GenericName> {
-}
-declare const entityHandlerKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsClean/entity-handler", unknown>>;
-export interface EntityHandler<GenericName extends string = string, GenericPropertiesDefinition extends EntityPropertiesDefinition = EntityPropertiesDefinition> extends Kind<typeof entityHandlerKind.definition> {
-    /**
-     * The entity name used as a runtime identifier (for example "User").
-     * 
-     */
-    readonly name: GenericName;
-    /**
-     * The properties schema returned by the definition callback.
-     * 
-     */
-    readonly propertiesDefinition: GenericPropertiesDefinition;
-    readonly mapDataParser: DDataParser.Contract<EntityProperties<GenericPropertiesDefinition>, unknown>;
-    /**
-     * Builds an entity from already typed properties.
-     * 
-     * ```ts
-     * 	export function create(params: {
-     * 		id: Id;
-     * 		name: Name;
-     * 	}) {
-     * 		return Entity.new({
-     * 			...params,
-     * 			nick: null,
-     * 			roles: [defaultRole],
-     * 		});
-     * ```
-     * 
-     */
-    "new"<const GenericProperties extends EntityProperties<GenericPropertiesDefinition>>(properties: GenericProperties): Entity<GenericName> & GenericProperties;
-    /**
-     * Validates permissive raw properties and returns an Either with the typed entity.
-     * 
-     * ```ts
-     * if (User.Entity.is(result)) {
-     * 	// result: C.Entity<"User">
-     * }
-     * 
-     * const mappedResult = User.Entity.map({
-     * 	id: 3,
-     * 	name: "Eve",
-     * 	roles: ["manager"],
-     * 	nick: null,
-     * ```
-     * 
-     */
-    map(rawProperties: PropertiesToMapOfEntity<GenericPropertiesDefinition>): (DEither.Right<"createEntity", Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>> | DEither.Left<"createEntityError", DDataParser.DataParserError>);
-    /**
-     * Validates permissive raw properties and throws on error.
-     * 
-     * ```ts
-     * const mapped = User.Entity.mapOrThrow({
-     * 	id: 2,
-     * 	name: "Bob",
-     * 	roles: ["client"],
-     * 	nick: "Bobby",
-     * });
-     * ```
-     * 
-     */
-    mapOrThrow(rawProperties: PropertiesToMapOfEntity<GenericPropertiesDefinition>): Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>;
-    /**
-    * Checks if a value is an entity of this handler (type guard).
-    * 
-    * ```ts
-    * const result = true ? mapped : null;
-    * 
-    * if (User.Entity.is(result)) {
-    * 	// result: C.Entity<"User">
-    * ```
-    * 
-    */
-    is<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, Entity<GenericName>>;
-    /**
-     * Updates an entity by merging typed properties into an existing entity.
-     * 
-     * ```ts
-     * const updated = User.Entity.update(mapped, {
-     * 	name: User.Name.createOrThrow("Bobby"),
-     * 	nick: null,
-     * });
-     * ```
-     * 
-     */
-    update<const GenericEntity extends Entity<GenericName>, const GenericProperties extends Partial<EntityProperties<GenericPropertiesDefinition>>>(entity: GenericEntity, properties: GenericProperties): Entity<GenericName> & DObject.AssignObjects<RemoveKind<GenericEntity>, GenericProperties>;
-}
-declare const CreateEntityError_base: new (params: {
-    "@DuplojsUtilsError/create-entity-error"?: unknown;
-}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("../common").KindDefinition<"create-entity-error", unknown>, unknown> & Kind<import("../common").KindDefinition<"@DuplojsUtilsError/create-entity-error", unknown>, unknown>;
-export declare class CreateEntityError extends CreateEntityError_base {
-    rawProperties: PropertiesToMapOfEntity;
-    dataParserError: DDataParser.DataParserError;
-    constructor(rawProperties: PropertiesToMapOfEntity, dataParserError: DDataParser.DataParserError);
-}
-export interface PropertiesDefinitionParams {
-    union<const GenericUnionPropertyDefinition extends EntityUnionPropertyDefinition>(...type: GenericUnionPropertyDefinition): {
-        type: GenericUnionPropertyDefinition;
-    };
-    nullable<const GenericPropertyDefinition extends EntityPropertyDefinition>(definition: GenericPropertyDefinition): GenericPropertyDefinition extends EntityAdvancedPropertyDefinition ? DObject.AssignObjects<GenericPropertyDefinition, {
-        nullable: true;
-    }> : {
-        type: GenericPropertyDefinition;
-        nullable: true;
-    };
-    array<const GenericPropertyDefinition extends EntityPropertyDefinition, const GenericAdvancedArrayPropertyDefinition extends EntityAdvancedArrayPropertyDefinition = never>(definition: GenericPropertyDefinition, params?: GenericAdvancedArrayPropertyDefinition): GenericPropertyDefinition extends EntityAdvancedPropertyDefinition ? DObject.AssignObjects<GenericPropertyDefinition, {
-        inArray: NeverCoalescing<GenericAdvancedArrayPropertyDefinition, true>;
-    }> : {
-        type: GenericPropertyDefinition;
-        inArray: NeverCoalescing<GenericAdvancedArrayPropertyDefinition, true>;
-    };
-}
-/**
- * Creates an entity handler from a property definition.
- * 
- * **Supported call styles:**
- * - Classic: `createEntity(name, getPropertiesDefinition)` -> returns a handler
- * 
- * Entities model business structures by composing NewTypes. The handler builds entities from typed properties or from raw inputs with validation.
- * 
- * ```ts
- * namespace User {
- * 	export const Id = C.createNewType("user-id", DP.number(), C.Positive);
- * 	export type Id = C.GetNewType<typeof Id>;
- * 	export const Name = C.createNewType("user-name", DP.string());
- * 	export type Name = C.GetNewType<typeof Name>;
- * 	export const Role = C.createNewType("UserRole", DP.literal(["admin", "client", "manager"]));
- * 
- * 	export const Entity = C.createEntity("User", ({ array, nullable }) => ({
- * 		id: Id,
- * 		name: Name,
- * 		roles: array(Role, { min: 1 }),
- * 		nick: nullable(Name),
- * 	}));
- * 	export type Entity = C.GetEntity<typeof Entity>;
- * 
- * 	const defaultRole = Role.createOrThrow("client");
- * 
- * 	export function create(params: {
- * 		id: Id;
- * 		name: Name;
- * 	}) {
- * 		return Entity.new({
- * 			...params,
- * 			nick: null,
- * 			roles: [defaultRole],
- * 		});
- * 	}
- * }
- * 
- * const mapped = User.Entity.mapOrThrow({
- * 	id: 2,
- * 	name: "Bob",
- * 	roles: ["client"],
- * 	nick: "Bobby",
- * });
- * 
- * const result = true ? mapped : null;
- * 
- * if (User.Entity.is(result)) {
- * 	// result: C.Entity<"User">
- * }
- * 
- * const mappedResult = User.Entity.map({
- * 	id: 3,
- * 	name: "Eve",
- * 	roles: ["manager"],
- * 	nick: null,
- * });
- * 
- * if (E.isRight(mappedResult)) {
- * 	// mappedResult: E.Right<"createEntity", C.Entity<"User">>
- * }
- * 
- * ```
- * 
- * @remarks
- * - The definition callback can use helpers like `array`, `nullable`, and `union` to enrich properties.
- * - Use `map`/`mapOrThrow` to build from raw inputs (with runtime constraint checks); `new` expects already typed values.
- * 
- * @see https://utils.duplojs.dev/en/v1/api/clean/entity
- * 
- * @namespace C
- * 
- */
-export declare function createEntity<GenericName extends string, const GenericPropertiesDefinition extends EntityPropertiesDefinition>(name: GenericName, getPropertiesDefinition: (params: PropertiesDefinitionParams) => GenericPropertiesDefinition & DObject.ForbiddenKey<GenericPropertiesDefinition, "_entityName" | "_flags">): EntityHandler<GenericName, GenericPropertiesDefinition>;
-export declare namespace createEntity {
-    var overrideHandler: import("../common").OverrideHandler<EntityHandler<string, Readonly<Record<string, EntityPropertyDefinition>>>>;
-}
-export type GetEntity<GenericEntityHandler extends EntityHandler<string, any>> = Extract<ReturnType<GenericEntityHandler["new"]>, any>;
-export {};

package/dist/clean/entity.mjs

@@ -1,141 +0,0 @@
-import { createCleanKind } from './kind.mjs';
-import { newTypeHandlerKind, newTypeKind } from './newType.mjs';
-import { asserts } from '../common/asserts.mjs';
-import { kindHeritage } from '../common/kind.mjs';
-import { pipe } from '../common/pipe.mjs';
-import { map } from '../array/map.mjs';
-import { toTuple } from '../array/toTuple.mjs';
-import { first } from '../array/at/first.mjs';
-import { innerPipe } from '../common/innerPipe.mjs';
-import { when } from '../pattern/when.mjs';
-import { isType } from '../common/isType.mjs';
-import { exhaustive } from '../pattern/exhaustive.mjs';
-import { when as when$1 } from '../common/when.mjs';
-import { array } from '../dataParser/parsers/array/index.mjs';
-import { checkerArrayMin } from '../dataParser/parsers/array/checkers/min.mjs';
-import { checkerArrayMax } from '../dataParser/parsers/array/checkers/max.mjs';
-import { nullable } from '../dataParser/parsers/nullable.mjs';
-import { dataParserKind } from '../dataParser/base.mjs';
-import { last } from '../array/at/last.mjs';
-import { entries } from '../object/entries.mjs';
-import { forward } from '../common/forward.mjs';
-import { createErrorKind } from '../common/errorKindNamespace.mjs';
-import { fromEntries } from '../object/fromEntries.mjs';
-import { entry } from '../object/entry.mjs';
-import { transform } from '../dataParser/parsers/transform.mjs';
-import { constrainedTypeKind } from './constraint/base.mjs';
-import { wrapValue } from '../common/wrapValue.mjs';
-import { minElements } from '../array/minElements.mjs';
-import { union } from '../dataParser/parsers/union.mjs';
-import { object } from '../dataParser/parsers/object/index.mjs';
-import { createOverride } from '../common/override.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';
-
-const entityKind = createCleanKind("entity");
-const entityHandlerKind = createCleanKind("entity-handler");
-class CreateEntityError extends kindHeritage("create-entity-error", createErrorKind("create-entity-error"), Error) {
-    rawProperties;
-    dataParserError;
-    constructor(rawProperties, dataParserError) {
-        super({}, ["Error when create entity."]);
-        this.rawProperties = rawProperties;
-        this.dataParserError = dataParserError;
-    }
-}
-/**
- * {@include clean/createEntity/index.md}
- */
-function createEntity(name, getPropertiesDefinition) {
-    function theNew(properties) {
-        return entityKind.addTo(properties, name);
-    }
-    function simplePropertyDefinitionToDataParser(simplePropertyDefinition) {
-        const constraintKindValue = pipe(simplePropertyDefinition.constraints, map(({ name }) => entry(name, null)), fromEntries);
-        return transform(simplePropertyDefinition.dataParser, (value) => constrainedTypeKind.setTo(newTypeKind.setTo(wrapValue(value), simplePropertyDefinition.name), constraintKindValue));
-    }
-    function unionPropertyDefinitionToDataParser(unionPropertyDefinition) {
-        return pipe(unionPropertyDefinition, map(simplePropertyDefinitionToDataParser), (options) => {
-            asserts(options, minElements(1));
-            return union(options);
-        });
-    }
-    const params = {
-        union: (...type) => ({ type }),
-        array: (definition, params) => (newTypeHandlerKind.has(definition) || definition instanceof Array
-            ? {
-                type: definition,
-                inArray: params ?? true,
-            }
-            : {
-                ...definition,
-                inArray: params ?? true,
-            }),
-        nullable: (definition) => (newTypeHandlerKind.has(definition) || definition instanceof Array
-            ? {
-                type: definition,
-                nullable: true,
-            }
-            : {
-                ...definition,
-                nullable: true,
-            }),
-    };
-    const propertiesDefinition = getPropertiesDefinition(params);
-    const mapDataParser = pipe(forward(propertiesDefinition), entries, map(toTuple([
-        first,
-        innerPipe(last, when(newTypeHandlerKind.has, simplePropertyDefinitionToDataParser), when(isType("array"), unionPropertyDefinitionToDataParser), when(isType("object"), (definition) => pipe(definition.type, when(newTypeHandlerKind.has, simplePropertyDefinitionToDataParser), when(isType("array"), unionPropertyDefinitionToDataParser), exhaustive, when$1(dataParserKind.has, innerPipe((dataParser) => {
-            if (definition.inArray) {
-                return pipe(array(dataParser), (dataParser) => typeof definition.inArray === "object"
-                    && definition.inArray.min !== undefined
-                    ? dataParser.addChecker(checkerArrayMin(definition.inArray.min))
-                    : dataParser, (dataParser) => typeof definition.inArray === "object"
-                    && definition.inArray.max !== undefined
-                    ? dataParser.addChecker(checkerArrayMax(definition.inArray.max))
-                    : dataParser);
-            }
-            return dataParser;
-        }, when$1(() => definition.nullable === true, nullable))))), exhaustive),
-    ])), fromEntries, object, (dataParser) => transform(dataParser, (value) => entityKind.setTo(value, name)));
-    function map$1(rawProperties) {
-        const result = mapDataParser.parse(rawProperties);
-        if (isLeft(result)) {
-            return left("createEntityError", unwrap(result));
-        }
-        return right("createEntity", unwrap(result));
-    }
-    function mapOrThrow(rawProperties) {
-        const result = mapDataParser.parse(rawProperties);
-        if (isLeft(result)) {
-            throw new CreateEntityError(rawProperties, unwrap(result));
-        }
-        return unwrap(result);
-    }
-    function is(input) {
-        return entityKind.has(input) && entityKind.getValue(input) === name;
-    }
-    function update(entity, newProperties) {
-        const updatedEntity = {};
-        for (const key in propertiesDefinition) {
-            updatedEntity[key] = newProperties[key] !== undefined
-                ? newProperties[key]
-                : entity[key];
-        }
-        return entityKind.setTo(updatedEntity, name);
-    }
-    return pipe({
-        name,
-        propertiesDefinition,
-        mapDataParser,
-        new: theNew,
-        map: map$1,
-        mapOrThrow,
-        is,
-        update,
-    }, entityHandlerKind.setTo, createEntity.overrideHandler.apply);
-}
-createEntity.overrideHandler = createOverride("@duplojs/utils/clean/entity");
-
-export { CreateEntityError, createEntity, entityKind };