@duplojs/utils 1.5.6 → 1.5.8

package/dist/clean/entity/index.cjs

@@ -0,0 +1,94 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var newType = require('../newType.cjs');
+var property = require('./property.cjs');
+var kind$1 = require('../../common/kind.cjs');
+var pipe = require('../../common/pipe.cjs');
+var map = require('../../array/map.cjs');
+var entry = require('../../object/entry.cjs');
+var fromEntries = require('../../object/fromEntries.cjs');
+var transform = require('../../dataParser/parsers/transform.cjs');
+var entries = require('../../object/entries.cjs');
+var forward = require('../../common/forward.cjs');
+var errorKindNamespace = require('../../common/errorKindNamespace.cjs');
+var index = require('../../dataParser/parsers/object/index.cjs');
+var base = require('../constraint/base.cjs');
+var wrapValue = require('../../common/wrapValue.cjs');
+var override = require('../../common/override.cjs');
+var is = require('../../either/left/is.cjs');
+var unwrap$1 = 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);
+    }
+    const propertiesDefinition = getPropertiesDefinition(property.entityPropertyDefinitionTools);
+    const mapDataParser = pipe.pipe(forward.forward(propertiesDefinition), entries.entries, map.map(([key, property$1]) => entry.entry(key, property.entityPropertyDefinitionToDataParser(property$1, (newTypeHandler) => {
+        const constraintKindValue = pipe.pipe(newTypeHandler.constraints, map.map(({ name }) => entry.entry(name, null)), fromEntries.fromEntries);
+        return transform.transform(newTypeHandler.dataParser, (value) => base.constrainedTypeKind.setTo(newType.newTypeKind.setTo(wrapValue.wrapValue(value), newTypeHandler.name), constraintKindValue));
+    }))), fromEntries.fromEntries, index.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$1.unwrap(result));
+        }
+        return create$1.right("createEntity", unwrap$1.unwrap(result));
+    }
+    function mapOrThrow(rawProperties) {
+        const result = mapDataParser.parse(rawProperties);
+        if (is.isLeft(result)) {
+            throw new CreateEntityError(rawProperties, unwrap$1.unwrap(result));
+        }
+        return unwrap$1.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.entityPropertyArrayKind = property.entityPropertyArrayKind;
+exports.entityPropertyDefinitionToDataParser = property.entityPropertyDefinitionToDataParser;
+exports.entityPropertyDefinitionTools = property.entityPropertyDefinitionTools;
+exports.entityPropertyNullableKind = property.entityPropertyNullableKind;
+exports.entityPropertyStructureKind = property.entityPropertyStructureKind;
+exports.entityPropertyUnionKind = property.entityPropertyUnionKind;
+exports.CreateEntityError = CreateEntityError;
+exports.createEntity = createEntity;
+exports.entityKind = entityKind;

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

@@ -0,0 +1,217 @@
+import { type SimplifyTopLevel, type Kind, type RemoveKind } from "../../common";
+import * as DEither from "../../either";
+import * as DDataParser from "../../dataParser";
+import * as DObject from "../../object";
+import { type EntityPropertyDefinition, type EntityProperty, type EntityRawProperty, type EntityInputRawProperty, entityPropertyDefinitionTools } from "./property";
+export * from "./property";
+export * from "./unwrap";
+export type EntityPropertiesDefinition = Readonly<Record<string, EntityPropertyDefinition>>;
+export type EntityProperties<GenericPropertiesDefinition extends EntityPropertiesDefinition = EntityPropertiesDefinition> = SimplifyTopLevel<{
+    readonly [Prop in keyof GenericPropertiesDefinition]: EntityProperty<GenericPropertiesDefinition[Prop]>;
+}>;
+export type EntityRawProperties<GenericPropertiesDefinition extends EntityPropertiesDefinition = EntityPropertiesDefinition> = SimplifyTopLevel<{
+    readonly [Prop in keyof GenericPropertiesDefinition]: EntityRawProperty<GenericPropertiesDefinition[Prop]>;
+}>;
+export type PropertiesToMapOfEntity<GenericPropertiesDefinition extends EntityPropertiesDefinition = EntityPropertiesDefinition> = SimplifyTopLevel<{
+    readonly [Prop in keyof GenericPropertiesDefinition]: EntityInputRawProperty<GenericPropertiesDefinition[Prop]>;
+}>;
+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
+     * 		preferences: structure({
+     * 			theme: PreferencesTheme,
+     * 			pinnedNick: nullable(Name),
+     * 		}),
+     * 	}));
+     * 	export type Entity = C.GetEntity<typeof Entity>;
+     * 
+     * 	const defaultRole = Role.createOrThrow("client");
+     * 
+     * ```
+     * 
+     */
+    "new"<const GenericProperties extends EntityProperties<GenericPropertiesDefinition>>(properties: GenericProperties): Entity<GenericName> & GenericProperties;
+    /**
+     * Validates permissive raw properties and returns an Either with the typed entity.
+     * 
+     * ```ts
+     * 		});
+     * 	}
+     * }
+     * 
+     * const mapped = User.Entity.mapOrThrow({
+     * 	id: 2,
+     * 	name: "Bob",
+     * 	roles: ["client"],
+     * 	nick: "Bobby",
+     * ```
+     * 
+     */
+    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
+     * 	}) {
+     * 		return Entity.new({
+     * 			...params,
+     * 			nick: null,
+     * 			roles: [defaultRole],
+     * 			preferences: {
+     * ```
+     * 
+     */
+    mapOrThrow(rawProperties: PropertiesToMapOfEntity<GenericPropertiesDefinition>): Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>;
+    /**
+    * Checks if a value is an entity of this handler (type guard).
+    * 
+    * ```ts
+    * 				pinnedNick: null,
+    * 			},
+    * 		});
+    * 	}
+    * ```
+    * 
+    */
+    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 result = true ? mapped : null;
+     * 
+     * if (User.Entity.is(result)) {
+     * 	// result: C.Entity<"User">
+     * ```
+     * 
+     */
+    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);
+}
+/**
+ * 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 PreferencesTheme = C.createNewType(
+ * 		"user-preferences-theme",
+ * 		DP.literal(["light", "dark"]),
+ * 	);
+ * 
+ * 	export const Entity = C.createEntity("User", ({ array, nullable, structure }) => ({
+ * 		id: Id,
+ * 		name: Name,
+ * 		roles: array(Role, { min: 1 }),
+ * 		nick: nullable(Name),
+ * 		preferences: structure({
+ * 			theme: PreferencesTheme,
+ * 			pinnedNick: 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],
+ * 			preferences: {
+ * 				theme: PreferencesTheme.createOrThrow("light"),
+ * 				pinnedNick: null,
+ * 			},
+ * 		});
+ * 	}
+ * }
+ * 
+ * const mapped = User.Entity.mapOrThrow({
+ * 	id: 2,
+ * 	name: "Bob",
+ * 	roles: ["client"],
+ * 	nick: "Bobby",
+ * 	preferences: {
+ * 		theme: "dark",
+ * 		pinnedNick: null,
+ * 	},
+ * });
+ * 
+ * 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,
+ * 	preferences: {
+ * 		theme: "light",
+ * 		pinnedNick: "Evy",
+ * 	},
+ * });
+ * 
+ * if (E.isRight(mappedResult)) {
+ * 	// mappedResult: E.Right<"createEntity", C.Entity<"User">>
+ * }
+ * 
+ * const updated = User.Entity.update(mapped, {
+ * 	name: User.Name.createOrThrow("Bobby"),
+ * 	nick: null,
+ * });
+ * ```
+ * 
+ * @remarks
+ * - The definition callback can use helpers like `array`, `nullable`, `union`, and `structure` 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: typeof entityPropertyDefinitionTools) => 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>;

package/dist/clean/entity/index.mjs

@@ -0,0 +1,85 @@
+import { createCleanKind } from '../kind.mjs';
+import { newTypeKind } from '../newType.mjs';
+import { entityPropertyDefinitionTools, entityPropertyDefinitionToDataParser } from './property.mjs';
+export { entityPropertyArrayKind, entityPropertyNullableKind, entityPropertyStructureKind, entityPropertyUnionKind } from './property.mjs';
+import { kindHeritage } from '../../common/kind.mjs';
+import { pipe } from '../../common/pipe.mjs';
+import { map } from '../../array/map.mjs';
+import { entry } from '../../object/entry.mjs';
+import { fromEntries } from '../../object/fromEntries.mjs';
+import { transform } from '../../dataParser/parsers/transform.mjs';
+import { entries } from '../../object/entries.mjs';
+import { forward } from '../../common/forward.mjs';
+import { createErrorKind } from '../../common/errorKindNamespace.mjs';
+import { object } from '../../dataParser/parsers/object/index.mjs';
+import { constrainedTypeKind } from '../constraint/base.mjs';
+import { wrapValue } from '../../common/wrapValue.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);
+    }
+    const propertiesDefinition = getPropertiesDefinition(entityPropertyDefinitionTools);
+    const mapDataParser = pipe(forward(propertiesDefinition), entries, map(([key, property]) => entry(key, entityPropertyDefinitionToDataParser(property, (newTypeHandler) => {
+        const constraintKindValue = pipe(newTypeHandler.constraints, map(({ name }) => entry(name, null)), fromEntries);
+        return transform(newTypeHandler.dataParser, (value) => constrainedTypeKind.setTo(newTypeKind.setTo(wrapValue(value), newTypeHandler.name), constraintKindValue));
+    }))), 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, entityPropertyDefinitionToDataParser, entityPropertyDefinitionTools };

package/dist/clean/entity/property.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+var newType = require('../newType.cjs');
+var kind = require('../kind.cjs');
+var pipe = require('../../common/pipe.cjs');
+var wrapValue = require('../../common/wrapValue.cjs');
+var when = require('../../pattern/when.cjs');
+var unwrap = require('../../common/unwrap.cjs');
+var entries = require('../../object/entries.cjs');
+var map = require('../../array/map.cjs');
+var entry = require('../../object/entry.cjs');
+var fromEntries = require('../../object/fromEntries.cjs');
+var index = require('../../dataParser/parsers/object/index.cjs');
+var index$1 = 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 union = require('../../dataParser/parsers/union.cjs');
+var exhaustive = require('../../pattern/exhaustive.cjs');
+
+const entityPropertyUnionKind = kind.createCleanKind("entity-property-union");
+const entityPropertyNullableKind = kind.createCleanKind("entity-property-nullable");
+const entityPropertyArrayKind = kind.createCleanKind("entity-property-array");
+const entityPropertyStructureKind = kind.createCleanKind("entity-property-structure");
+const entityPropertyDefinitionTools = {
+    union(...definitions) {
+        return pipe.pipe(definitions, wrapValue.wrapValue, entityPropertyUnionKind.setTo);
+    },
+    nullable(definition) {
+        return pipe.pipe(definition, wrapValue.wrapValue, entityPropertyNullableKind.setTo);
+    },
+    array(definition, params = {}) {
+        return pipe.pipe(definition, wrapValue.wrapValue, (value) => entityPropertyArrayKind.setTo(value, params));
+    },
+    structure(definition) {
+        return pipe.pipe(definition, wrapValue.wrapValue, entityPropertyStructureKind.setTo);
+    },
+};
+function entityPropertyDefinitionToDataParser(propertyDefinition, treatNewTypeHandler) {
+    return pipe.pipe(propertyDefinition, when.when(newType.newTypeHandlerKind.has, treatNewTypeHandler), when.when(entityPropertyUnionKind.has, (union$1) => {
+        const [firstInnerProperty, ...restInnerProperty] = unwrap.unwrap(union$1);
+        return union.union([
+            entityPropertyDefinitionToDataParser(firstInnerProperty, treatNewTypeHandler),
+            ...map.map(restInnerProperty, (innerProperty) => entityPropertyDefinitionToDataParser(innerProperty, treatNewTypeHandler)),
+        ]);
+    }), when.when(entityPropertyNullableKind.has, (nullable$1) => nullable.nullable(entityPropertyDefinitionToDataParser(unwrap.unwrap(nullable$1), treatNewTypeHandler))), when.when(entityPropertyArrayKind.has, (array) => {
+        const params = entityPropertyArrayKind.getValue(array);
+        return index$1.array(entityPropertyDefinitionToDataParser(unwrap.unwrap(array), treatNewTypeHandler), {
+            checkers: [
+                ...(params.min !== undefined
+                    ? [min.checkerArrayMin(params.min)]
+                    : []),
+                ...(params.max !== undefined
+                    ? [max.checkerArrayMax(params.max)]
+                    : []),
+            ],
+        });
+    }), when.when(entityPropertyStructureKind.has, (structure) => pipe.pipe(structure, unwrap.unwrap, entries.entries, map.map(([key, value]) => entry.entry(key, entityPropertyDefinitionToDataParser(value, treatNewTypeHandler))), fromEntries.fromEntries, index.object)), exhaustive.exhaustive);
+}
+
+exports.entityPropertyArrayKind = entityPropertyArrayKind;
+exports.entityPropertyDefinitionToDataParser = entityPropertyDefinitionToDataParser;
+exports.entityPropertyDefinitionTools = entityPropertyDefinitionTools;
+exports.entityPropertyNullableKind = entityPropertyNullableKind;
+exports.entityPropertyStructureKind = entityPropertyStructureKind;
+exports.entityPropertyUnionKind = entityPropertyUnionKind;

package/dist/clean/entity/property.d.ts

@@ -0,0 +1,43 @@
+import { type GetNewType, type NewTypeHandler } from "../newType";
+import { type WrappedValue, type Kind, type AnyTuple, type Unwrap, type GetKindValue, type IsEqual } from "../../common";
+import * as DDataParser from "../../dataParser";
+import * as DArray from "../../array";
+export type EntityPropertyDefinition = (NewTypeHandler | EntityPropertyDefinitionUnion | EntityPropertyDefinitionNullable | EntityPropertyDefinitionArray | EntityPropertyDefinitionStructure);
+export declare const entityPropertyUnionKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsClean/entity-property-union", unknown>>;
+export interface EntityPropertyDefinitionUnion<GenericPropertyDefinition extends AnyTuple<EntityPropertyDefinition> = AnyTuple<EntityPropertyDefinition>> extends Kind<typeof entityPropertyUnionKind.definition>, WrappedValue<GenericPropertyDefinition> {
+}
+export declare const entityPropertyNullableKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsClean/entity-property-nullable", unknown>>;
+export interface EntityPropertyDefinitionNullable<GenericPropertyDefinition extends EntityPropertyDefinition = EntityPropertyDefinition> extends Kind<typeof entityPropertyNullableKind.definition>, WrappedValue<GenericPropertyDefinition> {
+}
+export interface EntityPropertyDefinitionArrayParams {
+    readonly min?: number;
+    readonly max?: number;
+}
+export declare const entityPropertyArrayKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsClean/entity-property-array", EntityPropertyDefinitionArrayParams>>;
+export interface EntityPropertyDefinitionArray<GenericPropertyDefinition extends EntityPropertyDefinition = EntityPropertyDefinition, GenericParams extends EntityPropertyDefinitionArrayParams = EntityPropertyDefinitionArrayParams> extends Kind<typeof entityPropertyArrayKind.definition, GenericParams>, WrappedValue<GenericPropertyDefinition> {
+}
+export declare const entityPropertyStructureKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsClean/entity-property-structure", unknown>>;
+export interface EntityPropertyDefinitionStructure<GenericPropertyDefinition extends Record<string, EntityPropertyDefinition> = Record<string, EntityPropertyDefinition>> extends Kind<typeof entityPropertyStructureKind.definition>, WrappedValue<GenericPropertyDefinition> {
+}
+export type EntityProperty<GenericProperty extends EntityPropertyDefinition = EntityPropertyDefinition> = IsEqual<GenericProperty, EntityPropertyDefinition> extends true ? unknown : GenericProperty extends NewTypeHandler ? GetNewType<GenericProperty> : GenericProperty extends EntityPropertyDefinitionUnion ? EntityProperty<Unwrap<GenericProperty>[number]> : GenericProperty extends EntityPropertyDefinitionNullable ? EntityProperty<Unwrap<GenericProperty>> | null : GenericProperty extends EntityPropertyDefinitionArray ? GetKindValue<typeof entityPropertyArrayKind, GenericProperty>["min"] extends number ? EntityProperty<Unwrap<GenericProperty>> extends infer InferredEntityProperty ? readonly [
+    ...DArray.CreateTuple<InferredEntityProperty, GetKindValue<typeof entityPropertyArrayKind, GenericProperty>["min"]>,
+    ...InferredEntityProperty[]
+] : never : readonly EntityProperty<Unwrap<GenericProperty>>[] : GenericProperty extends EntityPropertyDefinitionStructure ? Unwrap<GenericProperty> extends infer InferredShape extends Record<string, any> ? {
+    readonly [Prop in keyof InferredShape]: EntityProperty<InferredShape[Prop]>;
+} : never : never;
+export type EntityRawProperty<GenericProperty extends EntityPropertyDefinition = EntityPropertyDefinition> = IsEqual<GenericProperty, EntityPropertyDefinition> extends true ? any : GenericProperty extends NewTypeHandler ? Unwrap<GetNewType<GenericProperty>> : GenericProperty extends EntityPropertyDefinitionUnion ? EntityRawProperty<Unwrap<GenericProperty>[number]> : GenericProperty extends EntityPropertyDefinitionNullable ? EntityRawProperty<Unwrap<GenericProperty>> | null : GenericProperty extends EntityPropertyDefinitionArray ? GetKindValue<typeof entityPropertyArrayKind, GenericProperty>["min"] extends number ? EntityRawProperty<Unwrap<GenericProperty>> extends infer InferredEntityProperty ? readonly [
+    ...DArray.CreateTuple<InferredEntityProperty, GetKindValue<typeof entityPropertyArrayKind, GenericProperty>["min"]>,
+    ...InferredEntityProperty[]
+] : never : readonly EntityRawProperty<Unwrap<GenericProperty>>[] : GenericProperty extends EntityPropertyDefinitionStructure ? Unwrap<GenericProperty> extends infer InferredEntityShape extends Record<string, any> ? {
+    readonly [Prop in keyof InferredEntityShape]: EntityRawProperty<InferredEntityShape[Prop]>;
+} : never : never;
+export type EntityInputRawProperty<GenericProperty extends EntityPropertyDefinition = EntityPropertyDefinition> = IsEqual<GenericProperty, EntityPropertyDefinition> extends true ? any : GenericProperty extends NewTypeHandler<any, infer InferredValue, any, infer InferredInput> ? IsEqual<InferredInput, never> extends true ? InferredValue : InferredInput : GenericProperty extends EntityPropertyDefinitionUnion ? EntityInputRawProperty<Unwrap<GenericProperty>[number]> : GenericProperty extends EntityPropertyDefinitionNullable ? EntityInputRawProperty<Unwrap<GenericProperty>> | null : GenericProperty extends EntityPropertyDefinitionArray ? readonly EntityInputRawProperty<Unwrap<GenericProperty>>[] : GenericProperty extends EntityPropertyDefinitionStructure ? Unwrap<GenericProperty> extends infer InferredShape extends Record<string, any> ? {
+    readonly [Prop in keyof InferredShape]: EntityInputRawProperty<InferredShape[Prop]>;
+} : never : never;
+export declare const entityPropertyDefinitionTools: {
+    union<const GenericDefinitionValue extends AnyTuple<EntityPropertyDefinition>>(...definitions: GenericDefinitionValue): EntityPropertyDefinitionUnion<GenericDefinitionValue>;
+    nullable<const GenericDefinitionValue extends EntityPropertyDefinition>(definition: GenericDefinitionValue): EntityPropertyDefinitionNullable<GenericDefinitionValue>;
+    array<const GenericDefinitionValue extends EntityPropertyDefinition, const GenericParams extends EntityPropertyDefinitionArrayParams = {}>(definition: GenericDefinitionValue, params?: GenericParams): EntityPropertyDefinitionArray<GenericDefinitionValue, GenericParams>;
+    structure<const GenericDefinitionValue extends Record<string, EntityPropertyDefinition>>(definition: GenericDefinitionValue): EntityPropertyDefinitionStructure<GenericDefinitionValue>;
+};
+export declare function entityPropertyDefinitionToDataParser(propertyDefinition: EntityPropertyDefinition, treatNewTypeHandler: (newTypeHandler: NewTypeHandler) => DDataParser.DataParser): DDataParser.DataParser;

package/dist/clean/entity/property.mjs

@@ -0,0 +1,59 @@
+import { newTypeHandlerKind } from '../newType.mjs';
+import { createCleanKind } from '../kind.mjs';
+import { pipe } from '../../common/pipe.mjs';
+import { wrapValue } from '../../common/wrapValue.mjs';
+import { when } from '../../pattern/when.mjs';
+import { unwrap } from '../../common/unwrap.mjs';
+import { entries } from '../../object/entries.mjs';
+import { map } from '../../array/map.mjs';
+import { entry } from '../../object/entry.mjs';
+import { fromEntries } from '../../object/fromEntries.mjs';
+import { object } from '../../dataParser/parsers/object/index.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 { union } from '../../dataParser/parsers/union.mjs';
+import { exhaustive } from '../../pattern/exhaustive.mjs';
+
+const entityPropertyUnionKind = createCleanKind("entity-property-union");
+const entityPropertyNullableKind = createCleanKind("entity-property-nullable");
+const entityPropertyArrayKind = createCleanKind("entity-property-array");
+const entityPropertyStructureKind = createCleanKind("entity-property-structure");
+const entityPropertyDefinitionTools = {
+    union(...definitions) {
+        return pipe(definitions, wrapValue, entityPropertyUnionKind.setTo);
+    },
+    nullable(definition) {
+        return pipe(definition, wrapValue, entityPropertyNullableKind.setTo);
+    },
+    array(definition, params = {}) {
+        return pipe(definition, wrapValue, (value) => entityPropertyArrayKind.setTo(value, params));
+    },
+    structure(definition) {
+        return pipe(definition, wrapValue, entityPropertyStructureKind.setTo);
+    },
+};
+function entityPropertyDefinitionToDataParser(propertyDefinition, treatNewTypeHandler) {
+    return pipe(propertyDefinition, when(newTypeHandlerKind.has, treatNewTypeHandler), when(entityPropertyUnionKind.has, (union$1) => {
+        const [firstInnerProperty, ...restInnerProperty] = unwrap(union$1);
+        return union([
+            entityPropertyDefinitionToDataParser(firstInnerProperty, treatNewTypeHandler),
+            ...map(restInnerProperty, (innerProperty) => entityPropertyDefinitionToDataParser(innerProperty, treatNewTypeHandler)),
+        ]);
+    }), when(entityPropertyNullableKind.has, (nullable$1) => nullable(entityPropertyDefinitionToDataParser(unwrap(nullable$1), treatNewTypeHandler))), when(entityPropertyArrayKind.has, (array$1) => {
+        const params = entityPropertyArrayKind.getValue(array$1);
+        return array(entityPropertyDefinitionToDataParser(unwrap(array$1), treatNewTypeHandler), {
+            checkers: [
+                ...(params.min !== undefined
+                    ? [checkerArrayMin(params.min)]
+                    : []),
+                ...(params.max !== undefined
+                    ? [checkerArrayMax(params.max)]
+                    : []),
+            ],
+        });
+    }), when(entityPropertyStructureKind.has, (structure) => pipe(structure, unwrap, entries, map(([key, value]) => entry(key, entityPropertyDefinitionToDataParser(value, treatNewTypeHandler))), fromEntries, object)), exhaustive);
+}
+
+export { entityPropertyArrayKind, entityPropertyDefinitionToDataParser, entityPropertyDefinitionTools, entityPropertyNullableKind, entityPropertyStructureKind, entityPropertyUnionKind };

package/dist/clean/entity/unwrap.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+var index = require('./index.cjs');
+var flag = require('../flag.cjs');
+var wrapValue = require('../../common/wrapValue.cjs');
+var unwrap = require('../../common/unwrap.cjs');
+
+/**
+ * {@include clean/unwrapEntity/index.md}
+ */
+function unwrapEntityProperty(property, params) {
+    if (wrapValue.isWrappedValue(property)) {
+        return params?.transformer
+            ? params.transformer(unwrap.unwrap(property))
+            : unwrap.unwrap(property);
+    }
+    else if (property === null) {
+        return property;
+    }
+    else if (property instanceof Array) {
+        const length = property.length;
+        const result = [];
+        for (let index = 0; index < length; index++) {
+            result[index] = unwrapEntityProperty(property[index], params);
+        }
+        return result;
+    }
+    else if (typeof property === "object"
+        && (!property.constructor
+            || property.constructor.name === "Object")) {
+        const result = {};
+        for (const key in property) {
+            result[key] = unwrapEntityProperty(property[key], params);
+        }
+        return result;
+    }
+    else {
+        return property;
+    }
+}
+function unwrapEntity(entity, params) {
+    const unwrapEntity = {};
+    for (const prop in entity) {
+        if (prop === index.entityKind.runTimeKey) {
+            unwrapEntity._entityName = entity[prop];
+        }
+        else if (prop === flag.flagKind.runTimeKey) {
+            unwrapEntity._flags = entity[prop];
+        }
+        else {
+            unwrapEntity[prop] = unwrapEntityProperty(entity[prop], params);
+        }
+    }
+    return unwrapEntity;
+}
+
+exports.unwrapEntity = unwrapEntity;
+exports.unwrapEntityProperty = unwrapEntityProperty;