@duplojs/utils 1.3.21 → 1.3.23

package/README.md

@@ -1,2 +1,22 @@
 # @duplojs/utils
-[![NPM version](https://img.shields.io/npm/v/@duplojs/utils)](https://www.npmjs.com/package/@duplojs/utils)
+[![NPM version](https://img.shields.io/npm/v/@duplojs/utils)](https://www.npmjs.com/package/@duplojs/utils)
+
+`@duplojs/utils` is the TypeScript utility toolbox used across the DuploJS ecosystem. It focuses on **strong typing**, **god DX**, and **small composable primitives** that scale from simple helpers to full validation pipelines.
+
+## What’s inside?
+
+- **Common functional utilities**: `pipe`/`asyncPipe`, `when`, `memo`, `clone`, `escapeRegExp`, etc.
+- **Typed runtime tagging**: `kind` helpers to discriminate data without polluting public shapes.
+- **Either**: a typed success/error container with mandatory “information” for precise pattern matching.
+- **DataParser**: schema-based validation with checkers, coercion (`DP.coerce.*`), transforms, async support, and a fluent “extended” API (`DPE`).
+- **Clean-domain building blocks**: `newType`, `entity`, constraints, repositories, and use-cases.
+- **Pure helpers by domain**: `array`, `object`, `string`, `number`, `date`, `generator`, `pattern` (match/exhaustive).
+
+## Documentation
+- https://utils.duplojs.dev
+
+## Install
+
+```bash
+npm install @duplojs/utils
+```

package/dist/array/index.cjs

@@ -42,6 +42,7 @@ var notIncludes = require('./notIncludes.cjs');
 var chunk = require('./chunk.cjs');
 var insert$2 = require('./insert.cjs');
 var isLastIndex = require('./isLastIndex.cjs');
+var select = require('./select.cjs');
 var _delete = require('./splice/delete.cjs');
 var insert = require('./splice/insert.cjs');
 var replace = require('./splice/replace.cjs');
@@ -101,6 +102,8 @@ exports.notIncludes = notIncludes.notIncludes;
 exports.chunk = chunk.chunk;
 exports.insert = insert$2.insert;
 exports.isLastIndex = isLastIndex.isLastIndex;
+exports.select = select.select;
+exports.selectTools = select.selectTools;
 exports.spliceDelete = _delete.spliceDelete;
 exports.spliceInsert = insert.spliceInsert;
 exports.spliceReplace = replace.spliceReplace;

package/dist/array/index.d.ts

@@ -45,3 +45,4 @@ export * from "./notIncludes";
 export * from "./chunk";
 export * from "./insert";
 export * from "./isLastIndex";
+export * from "./select";

package/dist/array/index.mjs

@@ -40,6 +40,7 @@ export { notIncludes } from './notIncludes.mjs';
 export { chunk } from './chunk.mjs';
 export { insert } from './insert.mjs';
 export { isLastIndex } from './isLastIndex.mjs';
+export { select, selectTools } from './select.mjs';
 export { spliceDelete } from './splice/delete.mjs';
 export { spliceInsert } from './splice/insert.mjs';
 export { spliceReplace } from './splice/replace.mjs';

package/dist/array/select.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+const selectTools = {
+    skip() {
+        return { "-skip": null };
+    },
+    select(output) {
+        return { "-select": output };
+    },
+};
+function select(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => select(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    const outputArray = [];
+    for (let index = 0; index < input.length; index++) {
+        const element = input[index];
+        const result = theFunction({
+            element,
+            index,
+            self: input,
+            ...selectTools,
+        });
+        if ("-skip" in result) {
+            continue;
+        }
+        outputArray.push(result["-select"]);
+    }
+    return outputArray;
+}
+
+exports.select = select;
+exports.selectTools = selectTools;

package/dist/array/select.d.ts

@@ -0,0 +1,18 @@
+import { type AnyValue } from "../common";
+export interface ArraySelectSelect<GenericOutput extends unknown = unknown> {
+    "-select": GenericOutput;
+}
+export interface ArraySelectSkip {
+    "-skip": null;
+}
+interface ArraySelectParams<GenericInputArray extends readonly unknown[]> {
+    element: GenericInputArray[number];
+    index: number;
+    self: GenericInputArray;
+    skip(): ArraySelectSkip;
+    select<GenericOutput extends AnyValue = AnyValue>(output: GenericOutput): ArraySelectSelect<GenericOutput>;
+}
+export declare const selectTools: Pick<ArraySelectParams<any>, "skip" | "select">;
+export declare function select<GenericInput extends readonly unknown[], GenericSelect extends ArraySelectSelect>(theFunction: (params: ArraySelectParams<GenericInput>) => GenericSelect | ArraySelectSkip): (input: GenericInput) => GenericSelect["-select"][];
+export declare function select<GenericInput extends readonly unknown[], GenericSelect extends ArraySelectSelect>(input: GenericInput, theFunction: (params: ArraySelectParams<GenericInput>) => GenericSelect | ArraySelectSkip): GenericSelect["-select"][];
+export {};

package/dist/array/select.mjs

@@ -0,0 +1,32 @@
+const selectTools = {
+    skip() {
+        return { "-skip": null };
+    },
+    select(output) {
+        return { "-select": output };
+    },
+};
+function select(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => select(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    const outputArray = [];
+    for (let index = 0; index < input.length; index++) {
+        const element = input[index];
+        const result = theFunction({
+            element,
+            index,
+            self: input,
+            ...selectTools,
+        });
+        if ("-skip" in result) {
+            continue;
+        }
+        outputArray.push(result["-select"]);
+    }
+    return outputArray;
+}
+
+export { select, selectTools };

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

@@ -32,5 +32,5 @@ export declare function createConstraint<GenericName extends string, GenericPrim
     DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>,
     ...DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>[]
 ]) = never>(name: GenericName, primitiveHandler: PrimitiveHandler<GenericPrimitiveValue>, checker: GenericChecker): ConstraintHandler<GenericName, GenericPrimitiveValue, DArray.ArrayCoalescing<GenericChecker>>;
-export type Constraint<GenericConstrainHandler extends ConstraintHandler, GenericValue extends DDataParser.InputChecker<GenericConstrainHandler["checkers"][number]> = DDataParser.InputChecker<GenericConstrainHandler["checkers"][number]>> = Extract<ConstrainedType<GenericConstrainHandler["name"], GenericValue>, any>;
+export type GetConstraint<GenericConstrainHandler extends ConstraintHandler, GenericValue extends DDataParser.InputChecker<GenericConstrainHandler["checkers"][number]> = DDataParser.InputChecker<GenericConstrainHandler["checkers"][number]>> = Extract<ConstrainedType<GenericConstrainHandler["name"], GenericValue>, any>;
 export {};

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

@@ -1,8 +1,8 @@
-import { type Constraint } from "../base";
+import { type GetConstraint } from "../base";
 import * as DDataParser from "../../../dataParser";
 export declare const Int: import("..").ConstraintHandler<"int", number, readonly [DDataParser.DataParserCheckerInt]>;
-export type Int = Constraint<typeof Int>;
+export type Int = GetConstraint<typeof Int>;
 export declare const Positive: import("..").ConstraintHandler<"positive", number, readonly [DDataParser.DataParserCheckerNumberMin]>;
-export type Positive = Constraint<typeof Positive>;
+export type Positive = GetConstraint<typeof Positive>;
 export declare const Negative: import("..").ConstraintHandler<"negative", number, readonly [DDataParser.DataParserCheckerNumberMax]>;
-export type Negative = Constraint<typeof Negative>;
+export type Negative = GetConstraint<typeof Negative>;

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

@@ -1,6 +1,6 @@
-import { type Constraint } from "../base";
+import { type GetConstraint } from "../base";
 import * as DDataParser from "../../../dataParser";
 export declare const Email: import("..").ConstraintHandler<"email", string, readonly [DDataParser.DataParserCheckerEmail]>;
-export type Email = Constraint<typeof Email>;
+export type Email = GetConstraint<typeof Email>;
 export declare const Url: import("..").ConstraintHandler<"url", string, readonly [DDataParser.DataParserCheckerUrl]>;
-export type Url = Constraint<typeof Url>;
+export type Url = GetConstraint<typeof Url>;

package/dist/clean/entity.cjs

@@ -110,6 +110,9 @@ function createEntity(name, getPropertiesDefinition) {
         }
         return unwrap.unwrap(result);
     }
+    function is$1(input) {
+        return entityKind.has(input) && entityKind.getValue(input) === name;
+    }
     return entityHandlerKind.setTo({
         name,
         propertiesDefinition,
@@ -117,6 +120,7 @@ function createEntity(name, getPropertiesDefinition) {
         new: theNew,
         map: map$1,
         mapOrThrow,
+        is: is$1,
     });
 }
 

package/dist/clean/entity.d.ts

@@ -43,6 +43,7 @@ export interface EntityHandler<GenericName extends string = string, GenericPrope
     "new"<GenericProperties extends EntityProperties<GenericPropertiesDefinition>>(properties: GenericProperties): Entity<GenericName> & GenericProperties;
     map(rawProperties: EntityRawProperties<GenericPropertiesDefinition>): (DEither.EitherRight<"createEntity", Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>> | DEither.EitherLeft<"createEntityError", DDataParser.DataParserError>);
     mapOrThrow(rawProperties: EntityRawProperties<GenericPropertiesDefinition>): Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>;
+    is<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, Entity<GenericName>>;
 }
 declare const CreateEntityError_base: new (params: {
     "@DuplojsUtilsError/create-entity-error"?: unknown;

package/dist/clean/entity.mjs

@@ -108,6 +108,9 @@ function createEntity(name, getPropertiesDefinition) {
         }
         return unwrap(result);
     }
+    function is(input) {
+        return entityKind.has(input) && entityKind.getValue(input) === name;
+    }
     return entityHandlerKind.setTo({
         name,
         propertiesDefinition,
@@ -115,6 +118,7 @@ function createEntity(name, getPropertiesDefinition) {
         new: theNew,
         map: map$1,
         mapOrThrow,
+        is,
     });
 }
 

package/dist/clean/flag.d.ts

@@ -13,4 +13,5 @@ export declare function createFlag<GenericEntity extends Entity = never, Generic
     IsEqual<GenericEntity, never>,
     IsEqual<GenericName, never>
 ]> extends true ? never : NoInfer<GenericName>): FlagHandler<GenericEntity, GenericName, GenericValue>;
+export type GetFlag<GenericHandler extends FlagHandler<any, any, any>> = Extract<Flag<GenericHandler["name"], ReturnType<GenericHandler["getValue"]>>, any>;
 export {};

package/dist/clean/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./types";
 export * from "./kind";
 export * from "./newType";
 export * from "./entity";

package/dist/clean/newType.d.ts

@@ -4,6 +4,7 @@ import { type Primitive, type EligiblePrimitive } from "./primitive";
 import * as DEither from "../either";
 import * as DArray from "../array";
 import type * as DDataParser from "../dataParser";
+import { type DataParserContainTransform } from "./types";
 export declare const newTypeKind: import("..").KindHandler<import("..").KindDefinition<"@DuplojsUtilsClean/new-type", string>>;
 type _NewType<GenericName extends string, GenericValue extends unknown, GenericConstrainName extends string> = (Kind<typeof newTypeKind.definition, GenericName> & Kind<typeof constrainedTypeKind.definition, Record<GenericConstrainName, unknown>> & WrappedValue<GenericValue>);
 export interface NewType<GenericName extends string = string, GenericValue extends unknown = unknown, GenericConstrainName extends string = never> extends _NewType<GenericName, GenericValue, GenericConstrainName> {
@@ -33,6 +34,6 @@ export declare class CreateNewTypeError extends CreateNewTypeError_base {
 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 []>>>;
+]) = never>(name: GenericName, dataParser: GenericDataParser & DataParserContainTransform<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/repository.d.ts

@@ -1,8 +1,8 @@
-import { type AnyFunction, type Kind } from "../common";
+import { type SimplifyTopLevel, type AnyFunction, type Kind } from "../common";
 export declare const repositoryHandlerKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsClean/repository-handler", unknown>>;
 export interface RepositoryHandler<GenericRepository extends object = object> extends Kind<typeof repositoryHandlerKind.definition> {
-    createImplementation(implementation: {
-        [Prop in keyof GenericRepository]: GenericRepository[Prop] extends AnyFunction ? AnyFunction<Parameters<GenericRepository[Prop]>, ReturnType<GenericRepository[Prop]>> : GenericRepository[Prop];
-    }): GenericRepository;
+    createImplementation(implementation: SimplifyTopLevel<{
+        [Prop in keyof GenericRepository]: GenericRepository[Prop] extends AnyFunction ? (...args: Parameters<GenericRepository[Prop]>) => ReturnType<GenericRepository[Prop]> : GenericRepository[Prop];
+    }>): GenericRepository;
 }
 export declare function createRepository<GenericRepository extends object>(): RepositoryHandler<GenericRepository>;

package/dist/clean/types/dataParserContainTransform.d.ts

@@ -0,0 +1,6 @@
+import type * as DDataParser from "../../dataParser";
+declare const SymbolErrorForbidden: unique symbol;
+export type DataParserContainTransform<GenericDataParser extends DDataParser.DataParser> = DDataParser.Contain<GenericDataParser, DDataParser.DataParserTransform> extends true ? {
+    [SymbolErrorForbidden]: "It is forbidden to use a transform dataParser.";
+} : GenericDataParser;
+export {};

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

@@ -0,0 +1 @@
+export * from "./dataParserContainTransform";

package/dist/clean/useCase.cjs

@@ -4,6 +4,7 @@ var kind = require('./kind.cjs');
 var pipe = require('../common/pipe.cjs');
 var map = require('../array/map.cjs');
 var entry = require('../object/entry.cjs');
+var uncapitalize = require('../string/uncapitalize.cjs');
 var entries = require('../object/entries.cjs');
 var fromEntries = require('../object/fromEntries.cjs');
 
@@ -11,13 +12,13 @@ const useCaseHandlerKind = kind.createCleanKind("use-case-handler");
 function createUseCase(dependencies, getUseCase) {
     return useCaseHandlerKind.setTo({
         dependencies,
-        getUseCase: (repositories) => getUseCase(pipe.pipe(dependencies, entries.entries, map.map(([key, value]) => entry.entry(key, useCaseHandlerKind.has(value)
+        getUseCase: (repositories) => getUseCase(pipe.pipe(dependencies, entries.entries, map.map(([key, value]) => entry.entry(uncapitalize.uncapitalize(key), useCaseHandlerKind.has(value)
             ? value.getUseCase(repositories)
-            : repositories[key])), fromEntries.fromEntries)),
+            : repositories[uncapitalize.uncapitalize(key)])), fromEntries.fromEntries)),
     });
 }
 function useCaseInstances(useCases, repositories) {
-    return pipe.pipe(useCases, entries.entries, map.map(([key, useCase]) => entry.entry(key, useCase.getUseCase(repositories))), fromEntries.fromEntries);
+    return pipe.pipe(useCases, entries.entries, map.map(([key, useCase]) => entry.entry(uncapitalize.uncapitalize(key), useCase.getUseCase(repositories))), fromEntries.fromEntries);
 }
 
 exports.createUseCase = createUseCase;

package/dist/clean/useCase.d.ts

@@ -2,11 +2,11 @@ import { type ObjectEntry, type Kind, type SimplifyTopLevel, type UnionToInterse
 import { type RepositoryHandler } from "./repository";
 export type UseCaseDependencies = Record<string, RepositoryHandler | UseCaseHandler>;
 export type UseCaseDependenciesValue<GenericDependencies extends UseCaseDependencies> = SimplifyTopLevel<{
-    [Prop in keyof GenericDependencies]: GenericDependencies[Prop] extends RepositoryHandler ? ReturnType<GenericDependencies[Prop]["createImplementation"]> : GenericDependencies[Prop] extends UseCaseHandler ? ReturnType<GenericDependencies[Prop]["getUseCase"]> : never;
+    [Prop in keyof GenericDependencies as (Prop extends string ? Uncapitalize<Prop> : Prop)]: GenericDependencies[Prop] extends RepositoryHandler ? ReturnType<GenericDependencies[Prop]["createImplementation"]> : GenericDependencies[Prop] extends UseCaseHandler ? ReturnType<GenericDependencies[Prop]["getUseCase"]> : never;
 }>;
 export type GetAllRepositories<GenericDependenciesValue extends UseCaseDependencies> = GenericDependenciesValue extends any ? ({
     [Prop in keyof GenericDependenciesValue]: (GenericDependenciesValue[Prop] extends RepositoryHandler ? [
-        Prop,
+        (Prop extends string ? Uncapitalize<Prop> : Prop),
         ReturnType<GenericDependenciesValue[Prop]["createImplementation"]>
     ] : GenericDependenciesValue[Prop] extends UseCaseHandler ? GetAllRepositories<GenericDependenciesValue[Prop]["dependencies"]> : never);
 })[keyof GenericDependenciesValue] : never;

package/dist/clean/useCase.mjs

@@ -2,6 +2,7 @@ import { createCleanKind } from './kind.mjs';
 import { pipe } from '../common/pipe.mjs';
 import { map } from '../array/map.mjs';
 import { entry } from '../object/entry.mjs';
+import { uncapitalize } from '../string/uncapitalize.mjs';
 import { entries } from '../object/entries.mjs';
 import { fromEntries } from '../object/fromEntries.mjs';
 
@@ -9,13 +10,13 @@ const useCaseHandlerKind = createCleanKind("use-case-handler");
 function createUseCase(dependencies, getUseCase) {
     return useCaseHandlerKind.setTo({
         dependencies,
-        getUseCase: (repositories) => getUseCase(pipe(dependencies, entries, map(([key, value]) => entry(key, useCaseHandlerKind.has(value)
+        getUseCase: (repositories) => getUseCase(pipe(dependencies, entries, map(([key, value]) => entry(uncapitalize(key), useCaseHandlerKind.has(value)
             ? value.getUseCase(repositories)
-            : repositories[key])), fromEntries)),
+            : repositories[uncapitalize(key)])), fromEntries)),
     });
 }
 function useCaseInstances(useCases, repositories) {
-    return pipe(useCases, entries, map(([key, useCase]) => entry(key, useCase.getUseCase(repositories))), fromEntries);
+    return pipe(useCases, entries, map(([key, useCase]) => entry(uncapitalize(key), useCase.getUseCase(repositories))), fromEntries);
 }
 
 export { createUseCase, useCaseHandlerKind, useCaseInstances };

package/dist/common/index.d.ts

@@ -13,7 +13,7 @@ export * from "./simpleClone";
 export * from "./sleep";
 export * from "./stringToBytes";
 export * from "./stringToMillisecond";
-export * from "./toJson";
+export * from "./toJSON";
 export * from "./toTransform";
 export * from "./toWrappedValue";
 export * from "./unwrap";

package/dist/common/{toJson.d.ts → toJSON.d.ts}

@@ -5,7 +5,7 @@ export type ToJSON<GenericValue extends unknown> = GenericValue extends number |
 }) ? ReturnType<GenericValue["toJSON"]> : GenericValue extends [infer InferredFirst, ...infer InferredRest] ? [
     ToJSON<InferredFirst>,
     ...(ToJSON<InferredRest> extends infer InferredSubRest extends any[] ? IsEqual<InferredSubRest, never[]> extends false ? InferredSubRest : [] : [])
-] : GenericValue extends any[] ? ToJSON<GenericValue[number]>[] : GenericValue extends Record<number, unknown> ? {
+] : GenericValue extends any[] ? ToJSON<GenericValue[number]>[] : GenericValue extends object ? {
     [Prop in keyof GenericValue as GenericValue[Prop] extends AnyFunction ? never : Prop]: ToJSON<GenericValue[Prop]>;
 } : undefined;
 export declare function toJSON<GenericValue extends unknown>(value: GenericValue): ToJSON<GenericValue>;

package/dist/dataParser/base.d.ts

@@ -33,6 +33,9 @@ export interface DataParser<GenericDefinition extends DataParserDefinition = Dat
     asyncParse(data: unknown): Promise<DEither.EitherSuccess<GenericOutput> | DEither.EitherError<DataParserError>>;
     addChecker(...args: never): DataParser;
     clone(): this;
+    /**
+     * @deprecated Method with unreliable typing.
+     */
     construct(definition: never): DataParser;
 }
 interface DataParserInitExecParams<GenericDataParser extends DataParser> {

package/dist/dataParser/baseExtended.d.ts

@@ -43,6 +43,9 @@ export interface DataParserExtended<GenericDefinition extends DataParserDefiniti
         inner: GenericThis;
         recoveredValue: GenericRecoveredValue;
     }>>;
+    /**
+     * @deprecated Method with unreliable typing.
+     */
     construct(definition: never): DataParserExtended;
 }
 export declare function dataParserExtendedInit<GenericDataParser extends DataParser, GenericDataParserExtended extends GenericDataParser & DataParserExtended>(dataParser: NoInfer<GenericDataParser>, rest: NoInfer<{

package/dist/dataParser/extended/array.d.ts

@@ -12,6 +12,9 @@ export interface DataParserArrayExtended<GenericDefinition extends dataParsers.D
         dataParsers.DataParserArrayCheckers<Output<this>>,
         ...dataParsers.DataParserArrayCheckers<Output<this>>[]
     ], GenericChecker>): DataParserArrayExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    /**
+     * @deprecated Method with unreliable typing.
+     */
     construct<const GenericDefinition extends dataParsers.DataParserDefinitionArray>(definition: GenericDefinition): DataParserArrayExtended<MergeDefinition<dataParsers.DataParserDefinitionArray, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserArrayExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>

package/dist/dataParser/extended/bigint.d.ts

@@ -12,6 +12,9 @@ export interface DataParserBigIntExtended<GenericDefinition extends dataParsers.
         dataParsers.DataParserBigIntCheckers,
         ...dataParsers.DataParserBigIntCheckers[]
     ], GenericChecker>): DataParserBigIntExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    /**
+     * @deprecated Method with unreliable typing.
+     */
     construct<const GenericDefinition extends dataParsers.DataParserDefinitionBigInt>(definition: GenericDefinition): DataParserBigIntExtended<MergeDefinition<dataParsers.DataParserDefinitionBigInt, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserBigIntExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>

package/dist/dataParser/extended/boolean.d.ts

@@ -12,6 +12,9 @@ export interface DataParserBooleanExtended<GenericDefinition extends dataParsers
         dataParsers.DataParserBooleanCheckers,
         ...dataParsers.DataParserBooleanCheckers[]
     ], GenericChecker>): DataParserBooleanExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    /**
+     * @deprecated Method with unreliable typing.
+     */
     construct<const GenericDefinition extends dataParsers.DataParserDefinitionBoolean>(definition: GenericDefinition): DataParserBooleanExtended<MergeDefinition<dataParsers.DataParserDefinitionBoolean, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserBooleanExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>

package/dist/dataParser/extended/date.d.ts

@@ -13,6 +13,9 @@ export interface DataParserDateExtended<GenericDefinition extends dataParsers.Da
         dataParsers.DataParserDateCheckers,
         ...dataParsers.DataParserDateCheckers[]
     ], GenericChecker>): DataParserDateExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    /**
+     * @deprecated Method with unreliable typing.
+     */
     construct<const GenericDefinition extends dataParsers.DataParserDefinitionDate>(definition: GenericDefinition): DataParserDateExtended<MergeDefinition<dataParsers.DataParserDefinitionDate, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserDateExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>

package/dist/dataParser/extended/empty.d.ts

@@ -12,6 +12,9 @@ export interface DataParserEmptyExtended<GenericDefinition extends dataParsers.D
         dataParsers.DataParserEmptyCheckers,
         ...dataParsers.DataParserEmptyCheckers[]
     ], GenericChecker>): DataParserEmptyExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    /**
+     * @deprecated Method with unreliable typing.
+     */
     construct<const GenericDefinition extends dataParsers.DataParserDefinitionEmpty>(definition: GenericDefinition): DataParserEmptyExtended<MergeDefinition<dataParsers.DataParserDefinitionEmpty, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserEmptyExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>

package/dist/dataParser/extended/lazy.d.ts

@@ -12,6 +12,9 @@ export interface DataParserLazyExtended<GenericDefinition extends dataParsers.Da
         dataParsers.DataParserLazyCheckers<Output<this>>,
         ...dataParsers.DataParserLazyCheckers<Output<this>>[]
     ], GenericChecker>): DataParserLazyExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    /**
+     * @deprecated Method with unreliable typing.
+     */
     construct<const GenericDefinition extends dataParsers.DataParserDefinitionLazy>(definition: GenericDefinition): DataParserLazyExtended<MergeDefinition<dataParsers.DataParserDefinitionLazy, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserLazyExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>

package/dist/dataParser/extended/literal.d.ts

@@ -12,6 +12,9 @@ export interface DataParserLiteralExtended<GenericDefinition extends dataParsers
         dataParsers.DataParserLiteralCheckers<Output<this>>,
         ...dataParsers.DataParserLiteralCheckers<Output<this>>[]
     ], GenericChecker>): DataParserLiteralExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    /**
+     * @deprecated Method with unreliable typing.
+     */
     construct<const GenericDefinition extends dataParsers.DataParserDefinitionLiteral>(definition: GenericDefinition): DataParserLiteralExtended<MergeDefinition<dataParsers.DataParserDefinitionLiteral, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserLiteralExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>

package/dist/dataParser/extended/nil.d.ts

@@ -12,6 +12,9 @@ export interface DataParserNilExtended<GenericDefinition extends dataParsers.Dat
         dataParsers.DataParserNilCheckers,
         ...dataParsers.DataParserNilCheckers[]
     ], GenericChecker>): DataParserNilExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    /**
+     * @deprecated Method with unreliable typing.
+     */
     construct<const GenericDefinition extends dataParsers.DataParserDefinitionNil>(definition: GenericDefinition): DataParserNilExtended<MergeDefinition<dataParsers.DataParserDefinitionNil, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserNilExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>

package/dist/dataParser/extended/nullable.d.ts

@@ -12,6 +12,9 @@ export interface DataParserNullableExtended<GenericDefinition extends dataParser
         dataParsers.DataParserNullableCheckers<Output<this>>,
         ...dataParsers.DataParserNullableCheckers<Output<this>>[]
     ], GenericChecker>): DataParserNullableExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    /**
+     * @deprecated Method with unreliable typing.
+     */
     construct<const GenericDefinition extends dataParsers.DataParserDefinitionNullable>(definition: GenericDefinition): DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserNullableExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>

package/dist/dataParser/extended/number.d.ts

@@ -12,6 +12,9 @@ export interface DataParserNumberExtended<GenericDefinition extends dataParsers.
         dataParsers.DataParserNumberCheckers,
         ...dataParsers.DataParserNumberCheckers[]
     ], GenericChecker>): DataParserNumberExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    /**
+     * @deprecated Method with unreliable typing.
+     */
     construct<const GenericDefinition extends dataParsers.DataParserDefinitionNumber>(definition: GenericDefinition): DataParserNumberExtended<MergeDefinition<dataParsers.DataParserDefinitionNumber, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserNumberExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>

package/dist/dataParser/extended/object.cjs

@@ -10,10 +10,22 @@ var override = require('../../common/override.cjs');
 
 function object(shape, definition) {
     const self = baseExtended.dataParserExtendedInit(index.object(shape, definition), {
-        omit: (self, omitObject, definition) => omit.omit(self, omitObject, definition),
-        pick: (self, pickObject, definition) => pick.pick(self, pickObject, definition),
-        partial: (self, definition) => partial.partial(self, definition),
-        required: (self, definition) => required.required(self, definition),
+        omit: (self, omitObject, definition) => {
+            const newShape = omit.omitShape(self.definition.shape, omitObject);
+            return object(newShape, definition);
+        },
+        pick: (self, pickObject, definition) => {
+            const newShape = pick.pickShape(self.definition.shape, pickObject);
+            return object(newShape, definition);
+        },
+        partial: (self, definition) => {
+            const newShape = partial.partialShape(self.definition.shape);
+            return object(newShape, definition);
+        },
+        required: (self, definition) => {
+            const newShape = required.requiredShape(self.definition.shape);
+            return object(newShape, definition);
+        },
     });
     return object.overrideHandler.apply(self);
 }

package/dist/dataParser/extended/object.d.ts

@@ -1,4 +1,4 @@
-import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../common";
+import { type Adaptor, type FixDeepFunctionInfer, type Kind, type NeverCoalescing, type SimplifyTopLevel } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
@@ -12,14 +12,25 @@ export interface DataParserObjectExtended<GenericDefinition extends dataParsers.
         dataParsers.DataParserObjectCheckers<Output<this>>,
         ...dataParsers.DataParserObjectCheckers<Output<this>>[]
     ], GenericChecker>): DataParserObjectExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    /**
+     * @deprecated Method with unreliable typing.
+     */
     construct<const GenericDefinition extends dataParsers.DataParserDefinitionObject>(definition: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserObjectExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
-    omit<const GenericOmitObject extends Partial<Record<keyof GenericDefinition["shape"], true>>, const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(omitObject: GenericOmitObject, definition?: GenericDefinition): ReturnType<typeof dataParsers.omit<dataParsers.DataParserObject<GenericDefinition>, GenericOmitObject, GenericSubDefinition>>;
-    pick<const GenericPickObject extends Partial<Record<keyof GenericDefinition["shape"], true>>, const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(pickObject: GenericPickObject, definition?: GenericDefinition): ReturnType<typeof dataParsers.pick<dataParsers.DataParserObject<GenericDefinition>, GenericPickObject, GenericSubDefinition>>;
-    partial<const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(definition?: GenericDefinition): ReturnType<typeof dataParsers.partial<dataParsers.DataParserObject<GenericDefinition>, GenericSubDefinition>>;
-    required<const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(definition?: GenericDefinition): ReturnType<typeof dataParsers.required<dataParsers.DataParserObject<GenericDefinition>, GenericSubDefinition>>;
+    omit<const GenericOmitObject extends Partial<Record<keyof GenericDefinition["shape"], true>>, const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(omitObject: GenericOmitObject, definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
+        readonly shape: SimplifyTopLevel<Omit<GenericDefinition["shape"], keyof GenericOmitObject>>;
+    }>>;
+    pick<const GenericPickObject extends Partial<Record<keyof GenericDefinition["shape"], true>>, const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(pickObject: GenericPickObject, definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
+        readonly shape: SimplifyTopLevel<Pick<GenericDefinition["shape"], Adaptor<keyof GenericPickObject, keyof GenericDefinition["shape"]>>>;
+    }>>;
+    partial<const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
+        readonly shape: dataParsers.PartialDataParserObject<GenericDefinition["shape"]>;
+    }>>;
+    required<const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
+        readonly shape: dataParsers.RequireDataParserObject<GenericDefinition["shape"]>;
+    }>>;
 }
 export declare function object<const GenericShape extends dataParsers.DataParserObjectShape, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     shape: GenericShape;