@duplojs/utils 1.2.18 → 1.2.19

package/dist/clean/entity.mjs

@@ -0,0 +1,121 @@
+import { createCleanKind } from './kind.mjs';
+import { newTypeHandlerKind, newTypeKind } from './newType.mjs';
+import { kindHeritage } from '../common/kind.mjs';
+import { pipe } from '../common/pipe.mjs';
+import { filter } from '../array/filter.mjs';
+import { isType } from '../common/isType.mjs';
+import { map } from '../array/map.mjs';
+import { entry } from '../object/entry.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 { 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 { transform } from '../dataParser/parsers/transform.mjs';
+import { constrainedTypeKind } from './constraint/base.mjs';
+import { wrapValue } from '../common/wrapValue.mjs';
+import { otherwise } from '../pattern/otherwise.mjs';
+import { justReturn } from '../common/justReturn.mjs';
+import { union } from '../dataParser/parsers/union.mjs';
+import { minElements } from '../array/minElements.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 { object } from '../dataParser/parsers/object/index.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;
+    }
+}
+function createEntity(name, getPropertiesDefinition) {
+    function theNew(properties) {
+        return entityKind.addTo(properties, name);
+    }
+    function simplePropertyDefinitionToDataParser(simplePropertyDefinition) {
+        const constraintKindValue = pipe(simplePropertyDefinition.constrains, 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), when(minElements(1), union), otherwise(justReturn(null)));
+    }
+    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),
+    ])), map(([key, value]) => value !== null && entry(key, value)), filter(isType("array")), 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);
+    }
+    return entityHandlerKind.setTo({
+        name,
+        propertiesDefinition,
+        mapDataParser,
+        new: theNew,
+        map: map$1,
+        mapOrThrow,
+    });
+}
+
+export { CreateEntityError, createEntity, entityKind };

package/dist/clean/flag.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var kind = require('./kind.cjs');
+
+const flagHandlerKind = kind.createCleanKind("flag-handler");
+const flagKind = kind.createCleanKind("flag");
+function createFlag(name) {
+    return flagHandlerKind.setTo({
+        name,
+        append(entity, value) {
+            const flagValue = flagKind.has(entity)
+                ? {
+                    ...flagKind.getValue(entity),
+                    [name]: value,
+                }
+                : { [name]: value };
+            return flagKind.addTo(entity, flagValue);
+        },
+        getValue(entity) {
+            return flagKind.getValue(entity)[name];
+        },
+    });
+}
+
+exports.createFlag = createFlag;
+exports.flagKind = flagKind;

package/dist/clean/flag.d.ts

@@ -0,0 +1,16 @@
+import { type Kind, type IsEqual, type Or, type GetKindValue } from "../common";
+import { type Entity } from "./entity";
+declare const flagHandlerKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsClean/flag-handler", unknown>>;
+export declare const flagKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsClean/flag", Record<string, unknown>>>;
+export interface FlagHandler<GenericEntity extends Entity = Entity, GenericName extends string = string, GenericValue extends unknown = never> extends Kind<typeof flagHandlerKind.definition> {
+    readonly name: GenericName;
+    append<GenericInputEntity extends GenericEntity, GenericInputValue extends GenericValue>(entity: GenericInputEntity, ...args: IsEqual<GenericValue, never> extends true ? [] : [GenericInputValue]): (GenericInputEntity & Flag<GenericName, GenericInputValue>);
+    getValue<GenericInputEntity extends GenericEntity & Flag<GenericName, GenericValue>>(entity: GenericInputEntity): GetKindValue<typeof flagKind, GenericInputEntity>[GenericName];
+}
+export interface Flag<GenericName extends string = string, GenericValue extends unknown = never> extends Kind<typeof flagKind.definition, Record<GenericName, GenericValue>> {
+}
+export declare function createFlag<GenericEntity extends Entity = never, GenericName extends string = never, GenericValue extends unknown = never>(name: Or<[
+    IsEqual<GenericEntity, never>,
+    IsEqual<GenericName, never>
+]> extends true ? never : NoInfer<GenericName>): FlagHandler<GenericEntity, GenericName, GenericValue>;
+export {};

package/dist/clean/flag.mjs

@@ -0,0 +1,23 @@
+import { createCleanKind } from './kind.mjs';
+
+const flagHandlerKind = createCleanKind("flag-handler");
+const flagKind = createCleanKind("flag");
+function createFlag(name) {
+    return flagHandlerKind.setTo({
+        name,
+        append(entity, value) {
+            const flagValue = flagKind.has(entity)
+                ? {
+                    ...flagKind.getValue(entity),
+                    [name]: value,
+                }
+                : { [name]: value };
+            return flagKind.addTo(entity, flagValue);
+        },
+        getValue(entity) {
+            return flagKind.getValue(entity)[name];
+        },
+    });
+}
+
+export { createFlag, flagKind };

package/dist/clean/index.cjs

@@ -0,0 +1,84 @@
+'use strict';
+
+var kind = require('./kind.cjs');
+var newType = require('./newType.cjs');
+var entity = require('./entity.cjs');
+var repository = require('./repository.cjs');
+var useCase = require('./useCase.cjs');
+var flag = require('./flag.cjs');
+var base = require('./constraint/base.cjs');
+var number = require('./constraint/defaultConstraint/number.cjs');
+var string = require('./constraint/defaultConstraint/string.cjs');
+var base$1 = require('./primitive/base.cjs');
+var equal = require('./primitive/operations/equal.cjs');
+var add = require('./primitive/operations/number/add.cjs');
+var divide = require('./primitive/operations/number/divide.cjs');
+var greaterThan = require('./primitive/operations/number/greaterThan.cjs');
+var lessThan = require('./primitive/operations/number/lessThan.cjs');
+var max = require('./primitive/operations/number/max.cjs');
+var min = require('./primitive/operations/number/min.cjs');
+var multiply = require('./primitive/operations/number/multiply.cjs');
+var subtract = require('./primitive/operations/number/subtract.cjs');
+var length = require('./primitive/operations/string/length.cjs');
+var lengthEqual = require('./primitive/operations/string/lengthEqual.cjs');
+var lengthGreaterThan = require('./primitive/operations/string/lengthGreaterThan.cjs');
+var lengthLessThan = require('./primitive/operations/string/lengthLessThan.cjs');
+var concat = require('./primitive/operations/string/concat.cjs');
+var dateGreaterThan = require('./primitive/operations/date/dateGreaterThan.cjs');
+var dateLessThan = require('./primitive/operations/date/dateLessThan.cjs');
+var dateMin = require('./primitive/operations/date/dateMin.cjs');
+var dateMax = require('./primitive/operations/date/dateMax.cjs');
+var sort = require('./primitive/operations/sort.cjs');
+
+
+
+exports.createCleanKind = kind.createCleanKind;
+exports.CreateNewTypeError = newType.CreateNewTypeError;
+exports.createNewType = newType.createNewType;
+exports.newTypeHandlerKind = newType.newTypeHandlerKind;
+exports.newTypeKind = newType.newTypeKind;
+exports.CreateEntityError = entity.CreateEntityError;
+exports.createEntity = entity.createEntity;
+exports.entityKind = entity.entityKind;
+exports.createRepository = repository.createRepository;
+exports.repositoryHandlerKind = repository.repositoryHandlerKind;
+exports.createUseCase = useCase.createUseCase;
+exports.useCaseHandlerKind = useCase.useCaseHandlerKind;
+exports.useCaseInstances = useCase.useCaseInstances;
+exports.createFlag = flag.createFlag;
+exports.flagKind = flag.flagKind;
+exports.CreateConstrainedTypeError = base.CreateConstrainedTypeError;
+exports.constrainedTypeKind = base.constrainedTypeKind;
+exports.constraintHandlerKind = base.constraintHandlerKind;
+exports.createConstraint = base.createConstraint;
+exports.Int = number.Int;
+exports.Negative = number.Negative;
+exports.Positive = number.Positive;
+exports.Email = string.Email;
+exports.Url = string.Url;
+exports.BigInt = base$1.BigInt;
+exports.Boolean = base$1.Boolean;
+exports.CreatePrimitiveError = base$1.CreatePrimitiveError;
+exports.Date = base$1.Date;
+exports.Number = base$1.Number;
+exports.String = base$1.String;
+exports.primitiveHandlerKind = base$1.primitiveHandlerKind;
+exports.equal = equal.equal;
+exports.add = add.add;
+exports.divide = divide.divide;
+exports.greaterThan = greaterThan.greaterThan;
+exports.lessThan = lessThan.lessThan;
+exports.max = max.max;
+exports.min = min.min;
+exports.multiply = multiply.multiply;
+exports.subtract = subtract.subtract;
+exports.length = length.length;
+exports.lengthEqual = lengthEqual.lengthEqual;
+exports.lengthGreaterThan = lengthGreaterThan.lengthGreaterThan;
+exports.lengthLessThan = lengthLessThan.lengthLessThan;
+exports.concat = concat.concat;
+exports.dateGreaterThan = dateGreaterThan.dateGreaterThan;
+exports.dateLessThan = dateLessThan.dateLessThan;
+exports.dateMin = dateMin.dateMin;
+exports.dateMax = dateMax.dateMax;
+exports.sort = sort.sort;

package/dist/clean/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./kind";
+export * from "./newType";
+export * from "./entity";
+export * from "./constraint";
+export * from "./primitive";
+export * from "./repository";
+export * from "./useCase";
+export * from "./flag";

package/dist/clean/index.mjs

@@ -0,0 +1,29 @@
+export { createCleanKind } from './kind.mjs';
+export { CreateNewTypeError, createNewType, newTypeHandlerKind, newTypeKind } from './newType.mjs';
+export { CreateEntityError, createEntity, entityKind } from './entity.mjs';
+export { createRepository, repositoryHandlerKind } from './repository.mjs';
+export { createUseCase, useCaseHandlerKind, useCaseInstances } from './useCase.mjs';
+export { createFlag, flagKind } from './flag.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 { BigInt, Boolean, CreatePrimitiveError, Date, Number, String, primitiveHandlerKind } from './primitive/base.mjs';
+export { equal } from './primitive/operations/equal.mjs';
+export { add } from './primitive/operations/number/add.mjs';
+export { divide } from './primitive/operations/number/divide.mjs';
+export { greaterThan } from './primitive/operations/number/greaterThan.mjs';
+export { lessThan } from './primitive/operations/number/lessThan.mjs';
+export { max } from './primitive/operations/number/max.mjs';
+export { min } from './primitive/operations/number/min.mjs';
+export { multiply } from './primitive/operations/number/multiply.mjs';
+export { subtract } from './primitive/operations/number/subtract.mjs';
+export { length } from './primitive/operations/string/length.mjs';
+export { lengthEqual } from './primitive/operations/string/lengthEqual.mjs';
+export { lengthGreaterThan } from './primitive/operations/string/lengthGreaterThan.mjs';
+export { lengthLessThan } from './primitive/operations/string/lengthLessThan.mjs';
+export { concat } from './primitive/operations/string/concat.mjs';
+export { dateGreaterThan } from './primitive/operations/date/dateGreaterThan.mjs';
+export { dateLessThan } from './primitive/operations/date/dateLessThan.mjs';
+export { dateMin } from './primitive/operations/date/dateMin.mjs';
+export { dateMax } from './primitive/operations/date/dateMax.mjs';
+export { sort } from './primitive/operations/sort.mjs';

package/dist/clean/kind.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var kind = require('../common/kind.cjs');
+
+const createCleanKind = kind.createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsUtilsClean");
+
+exports.createCleanKind = createCleanKind;

package/dist/clean/kind.d.ts

@@ -0,0 +1 @@
+export declare const createCleanKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import("../string").ForbiddenString<GenericName, "@" | "/">) => import("../common").KindHandler<import("../common").KindDefinition<`@DuplojsUtilsClean/${GenericName}`, GenericKindValue>>;

package/dist/clean/kind.mjs

@@ -0,0 +1,7 @@
+import { createKindNamespace } from '../common/kind.mjs';
+
+const createCleanKind = createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsUtilsClean");
+
+export { createCleanKind };

package/dist/clean/newType.cjs

@@ -0,0 +1,91 @@
+'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');
+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 newTypeKind = kind.createCleanKind("new-type");
+const newTypeHandlerKind = kind.createCleanKind("new-type-handler");
+class CreateNewTypeError extends kind$1.kindHeritage("create-new-type-error", errorKindNamespace.createErrorKind("create-new-type-error"), Error) {
+    newTypeName;
+    data;
+    dataParserError;
+    constructor(newTypeName, data, dataParserError) {
+        super({}, [`Error when create new type ${newTypeName}.`]);
+        this.newTypeName = newTypeName;
+        this.data = data;
+        this.dataParserError = dataParserError;
+    }
+}
+function createNewType(name, dataParser, constraint) {
+    const constrains = coalescing.coalescing(constraint ?? []);
+    const checkers = flatMap.flatMap(constrains, ({ checkers }) => checkers);
+    const dataParserWithCheckers = constraint
+        ? dataParser.addChecker(...checkers)
+        : dataParser;
+    const constraintKindValue = pipe.pipe(constrains, map.map(({ name }) => entry.entry(name, null)), fromEntries.fromEntries);
+    function create$2(data) {
+        const result = dataParserWithCheckers.parse(unwrap.unwrap(data));
+        if (is.isLeft(result)) {
+            return create.left("createNewTypeError", unwrap.unwrap(result));
+        }
+        else if (base.constrainedTypeKind.has(data)) {
+            return create$1.right("createNewType", newTypeKind.setTo(base.constrainedTypeKind.addTo(data, {
+                ...base.constrainedTypeKind.getValue(data),
+                ...constraintKindValue,
+            }), name));
+        }
+        else {
+            return create$1.right("createNewType", newTypeKind.setTo(base.constrainedTypeKind.setTo(wrapValue.wrapValue(unwrap.unwrap(result)), constraintKindValue), name));
+        }
+    }
+    function createOrThrow(data) {
+        const result = create$2(data);
+        if (is.isLeft(result)) {
+            throw new CreateNewTypeError(name, data, unwrap.unwrap(result));
+        }
+        else {
+            return unwrap.unwrap(result);
+        }
+    }
+    function is$1(input) {
+        if (!newTypeKind.has(input)
+            || newTypeKind.getValue(input) !== name) {
+            return false;
+        }
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
+        for (let index = 0; index < constrains.length; index++) {
+            if (!constrains[index].is(input)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return newTypeHandlerKind.setTo({
+        name,
+        dataParser: dataParserWithCheckers,
+        constrains,
+        create: create$2,
+        createOrThrow,
+        createWithUnknown: create$2,
+        createWithUnknownOrThrow: createOrThrow,
+        is: is$1,
+    });
+}
+
+exports.CreateNewTypeError = CreateNewTypeError;
+exports.createNewType = createNewType;
+exports.newTypeHandlerKind = newTypeHandlerKind;
+exports.newTypeKind = newTypeKind;

package/dist/clean/newType.d.ts

@@ -0,0 +1,38 @@
+import { type Kind, type WrappedValue, type Unwrap, type NeverCoalescing } from "..";
+import { constrainedTypeKind, type ConstraintHandler } from "./constraint";
+import { type Primitive, type EligiblePrimitive } from "./primitive";
+import * as DEither from "../either";
+import * as DArray from "../array";
+import type * as DDataParser from "../dataParser";
+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> {
+}
+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> {
+    readonly name: GenericName;
+    readonly dataParser: DDataParser.Contract<GenericValue>;
+    readonly constrains: GenericConstrainHandler;
+    create<const GenericData extends GenericValue>(data: GenericData): (DEither.EitherRight<"createNewType", NewType<GenericName, GenericData, GenericConstrainHandler[number]["name"]>> | DEither.EitherLeft<"createNewTypeError", DDataParser.DataParserError>);
+    create<GenericPrimitive extends Primitive<Extract<GenericValue, EligiblePrimitive>>>(data: GenericPrimitive): (DEither.EitherRight<"createNewType", (GenericPrimitive & NewType<GenericName, Unwrap<GenericPrimitive>, GenericConstrainHandler[number]["name"]>)> | DEither.EitherLeft<"createNewTypeError", DDataParser.DataParserError>);
+    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"]>);
+    createWithUnknown<GenericData extends unknown>(data: GenericData): (DEither.EitherRight<"createNewType", NewType<GenericName, GenericValue, GenericConstrainHandler[number]["name"]>> | DEither.EitherLeft<"createNewTypeError", DDataParser.DataParserError>);
+    createWithUnknownOrThrow<GenericData extends unknown>(data: GenericData): NewType<GenericName, GenericValue, GenericConstrainHandler[number]["name"]>;
+    is<GenericInput extends WrappedValue>(input: GenericInput): input is Extract<GenericInput, NewType<GenericName, GenericValue, GenericConstrainHandler[number]["name"]>>;
+}
+declare const CreateNewTypeError_base: new (params: {
+    "@DuplojsUtilsError/create-new-type-error"?: unknown;
+}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("..").KindDefinition<"create-new-type-error", unknown>, unknown> & Kind<import("..").KindDefinition<"@DuplojsUtilsError/create-new-type-error", unknown>, unknown>;
+export declare class CreateNewTypeError extends CreateNewTypeError_base {
+    newTypeName: string;
+    data: unknown;
+    dataParserError: DDataParser.DataParserError;
+    constructor(newTypeName: string, data: unknown, dataParserError: DDataParser.DataParserError);
+}
+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 [
+    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, constraint?: GenericConstrainHandler): NewTypeHandler<GenericName, DDataParser.Output<GenericDataParser>, DArray.ArrayCoalescing<NeverCoalescing<GenericConstrainHandler, 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

@@ -0,0 +1,86 @@
+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';
+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 newTypeKind = createCleanKind("new-type");
+const newTypeHandlerKind = createCleanKind("new-type-handler");
+class CreateNewTypeError extends kindHeritage("create-new-type-error", createErrorKind("create-new-type-error"), Error) {
+    newTypeName;
+    data;
+    dataParserError;
+    constructor(newTypeName, data, dataParserError) {
+        super({}, [`Error when create new type ${newTypeName}.`]);
+        this.newTypeName = newTypeName;
+        this.data = data;
+        this.dataParserError = dataParserError;
+    }
+}
+function createNewType(name, dataParser, constraint) {
+    const constrains = coalescing(constraint ?? []);
+    const checkers = flatMap(constrains, ({ checkers }) => checkers);
+    const dataParserWithCheckers = constraint
+        ? dataParser.addChecker(...checkers)
+        : dataParser;
+    const constraintKindValue = pipe(constrains, map(({ name }) => entry(name, null)), fromEntries);
+    function create(data) {
+        const result = dataParserWithCheckers.parse(unwrap(data));
+        if (isLeft(result)) {
+            return left("createNewTypeError", unwrap(result));
+        }
+        else if (constrainedTypeKind.has(data)) {
+            return right("createNewType", newTypeKind.setTo(constrainedTypeKind.addTo(data, {
+                ...constrainedTypeKind.getValue(data),
+                ...constraintKindValue,
+            }), name));
+        }
+        else {
+            return right("createNewType", newTypeKind.setTo(constrainedTypeKind.setTo(wrapValue(unwrap(result)), constraintKindValue), name));
+        }
+    }
+    function createOrThrow(data) {
+        const result = create(data);
+        if (isLeft(result)) {
+            throw new CreateNewTypeError(name, data, unwrap(result));
+        }
+        else {
+            return unwrap(result);
+        }
+    }
+    function is(input) {
+        if (!newTypeKind.has(input)
+            || newTypeKind.getValue(input) !== name) {
+            return false;
+        }
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
+        for (let index = 0; index < constrains.length; index++) {
+            if (!constrains[index].is(input)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return newTypeHandlerKind.setTo({
+        name,
+        dataParser: dataParserWithCheckers,
+        constrains,
+        create,
+        createOrThrow,
+        createWithUnknown: create,
+        createWithUnknownOrThrow: createOrThrow,
+        is,
+    });
+}
+
+export { CreateNewTypeError, createNewType, newTypeHandlerKind, newTypeKind };

package/dist/clean/primitive/base.cjs

@@ -0,0 +1,72 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var kind$1 = require('../../common/kind.cjs');
+var index = require('../../dataParser/parsers/string/index.cjs');
+var index$1 = require('../../dataParser/parsers/number/index.cjs');
+var index$2 = require('../../dataParser/parsers/bigint/index.cjs');
+var boolean = require('../../dataParser/parsers/boolean.cjs');
+var date = require('../../dataParser/parsers/date.cjs');
+var errorKindNamespace = require('../../common/errorKindNamespace.cjs');
+var unwrap = require('../../common/unwrap.cjs');
+var is = require('../../either/right/is.cjs');
+var is$1 = require('../../either/left/is.cjs');
+var create = require('../../either/left/create.cjs');
+var create$1 = require('../../either/right/create.cjs');
+var wrapValue = require('../../common/wrapValue.cjs');
+
+const primitiveHandlerKind = kind.createCleanKind("primitive-handler");
+class CreatePrimitiveError extends kind$1.kindHeritage("create-primitive-error", errorKindNamespace.createErrorKind("create-primitive-error"), Error) {
+    data;
+    dataParserError;
+    constructor(data, dataParserError) {
+        super({}, ["Error when create primitive."]);
+        this.data = data;
+        this.dataParserError = dataParserError;
+    }
+}
+function createPrimitive(dataParser) {
+    function create$2(data) {
+        const result = dataParser.parse(data);
+        if (is$1.isLeft(result)) {
+            return create.left("createPrimitiveError", unwrap.unwrap(result));
+        }
+        else {
+            return create$1.right("createPrimitive", wrapValue.wrapValue(unwrap.unwrap(result)));
+        }
+    }
+    function createOrThrow(data) {
+        const result = create$2(data);
+        if (is$1.isLeft(result)) {
+            throw new CreatePrimitiveError(data, unwrap.unwrap(result));
+        }
+        else {
+            return unwrap.unwrap(result);
+        }
+    }
+    function is$2(input) {
+        const result = dataParser.parse(unwrap.unwrap(input));
+        return is.isRight(result);
+    }
+    return primitiveHandlerKind.setTo({
+        dataParser,
+        create: create$2,
+        createOrThrow,
+        createWithUnknown: create$2,
+        createWithUnknownOrThrow: createOrThrow,
+        is: is$2,
+    });
+}
+const String = createPrimitive(index.string());
+const Number = createPrimitive(index$1.number());
+const BigInt = createPrimitive(index$2.bigint());
+const Boolean = createPrimitive(boolean.boolean());
+const Date = createPrimitive(date.date());
+
+exports.BigInt = BigInt;
+exports.Boolean = Boolean;
+exports.CreatePrimitiveError = CreatePrimitiveError;
+exports.Date = Date;
+exports.Number = Number;
+exports.String = String;
+exports.primitiveHandlerKind = primitiveHandlerKind;