@duplojs/utils 1.2.18 → 1.2.19

package/dist/clean/primitive/operations/sort.mjs

@@ -0,0 +1,33 @@
+import { unwrap } from '../../../common/unwrap.mjs';
+import { sort as sort$1 } from '../../../number/sort.mjs';
+import { wrapValue } from '../../../common/wrapValue.mjs';
+import { is } from '../../../date/is.mjs';
+import { sort as sort$2 } from '../../../date/sort.mjs';
+import { sort as sort$3 } from '../../../string/sort.mjs';
+
+function sort(...args) {
+    if (args.length === 1) {
+        const [type] = args;
+        return ((input) => sort(input, type));
+    }
+    const [input, type] = args;
+    const rawArray = input.map(unwrap);
+    const first = rawArray.at(0);
+    if (!first) {
+        return [];
+    }
+    if (typeof first === "number") {
+        return sort$1(rawArray, type)
+            .map(wrapValue);
+    }
+    else if (is(first)) {
+        return sort$2(rawArray, type)
+            .map(wrapValue);
+    }
+    else {
+        return sort$3(rawArray, type)
+            .map(wrapValue);
+    }
+}
+
+export { sort };

package/dist/clean/primitive/operations/string/concat.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var wrapValue = require('../../../../common/wrapValue.cjs');
+var unwrap = require('../../../../common/unwrap.cjs');
+
+function concat(...args) {
+    if (args.length === 1) {
+        const [text] = args;
+        return (input) => concat(input, text);
+    }
+    const [input, ...textsRest] = args;
+    return wrapValue.wrapValue(unwrap.unwrap(input)
+        .concat(...textsRest.map(unwrap.unwrap)));
+}
+
+exports.concat = concat;

package/dist/clean/primitive/operations/string/concat.d.ts

@@ -0,0 +1,3 @@
+import { type String } from "../../base";
+export declare function concat(text: String | string): (input: String) => String;
+export declare function concat(input: String, ...textsRest: (String | string)[]): String;

package/dist/clean/primitive/operations/string/concat.mjs

@@ -0,0 +1,14 @@
+import { wrapValue } from '../../../../common/wrapValue.mjs';
+import { unwrap } from '../../../../common/unwrap.mjs';
+
+function concat(...args) {
+    if (args.length === 1) {
+        const [text] = args;
+        return (input) => concat(input, text);
+    }
+    const [input, ...textsRest] = args;
+    return wrapValue(unwrap(input)
+        .concat(...textsRest.map(unwrap)));
+}
+
+export { concat };

package/dist/clean/primitive/operations/string/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./length";
+export * from "./lengthEqual";
+export * from "./lengthGreaterThan";
+export * from "./lengthLessThan";
+export * from "./concat";

package/dist/clean/primitive/operations/string/length.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var wrapValue = require('../../../../common/wrapValue.cjs');
+var unwrap = require('../../../../common/unwrap.cjs');
+
+function length(primitive) {
+    return wrapValue.wrapValue(unwrap.unwrap(primitive).length);
+}
+
+exports.length = length;

package/dist/clean/primitive/operations/string/length.d.ts

@@ -0,0 +1,2 @@
+import { type Number, type String } from "../../base";
+export declare function length(primitive: String): Number;

package/dist/clean/primitive/operations/string/length.mjs

@@ -0,0 +1,8 @@
+import { wrapValue } from '../../../../common/wrapValue.mjs';
+import { unwrap } from '../../../../common/unwrap.mjs';
+
+function length(primitive) {
+    return wrapValue(unwrap(primitive).length);
+}
+
+export { length };

package/dist/clean/primitive/operations/string/lengthEqual.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var unwrap = require('../../../../common/unwrap.cjs');
+
+function lengthEqual(...args) {
+    if (args.length === 1) {
+        const [length] = args;
+        return (primitive) => lengthEqual(primitive, length);
+    }
+    const [primitive, length] = args;
+    return unwrap.unwrap(primitive).length === unwrap.unwrap(length);
+}
+
+exports.lengthEqual = lengthEqual;

package/dist/clean/primitive/operations/string/lengthEqual.d.ts

@@ -0,0 +1,3 @@
+import { type Number, type String } from "../../base";
+export declare function lengthEqual(length: Number | number): (primitive: String) => boolean;
+export declare function lengthEqual(primitive: String, length: Number | number): boolean;

package/dist/clean/primitive/operations/string/lengthEqual.mjs

@@ -0,0 +1,12 @@
+import { unwrap } from '../../../../common/unwrap.mjs';
+
+function lengthEqual(...args) {
+    if (args.length === 1) {
+        const [length] = args;
+        return (primitive) => lengthEqual(primitive, length);
+    }
+    const [primitive, length] = args;
+    return unwrap(primitive).length === unwrap(length);
+}
+
+export { lengthEqual };

package/dist/clean/primitive/operations/string/lengthGreaterThan.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var unwrap = require('../../../../common/unwrap.cjs');
+
+function lengthGreaterThan(...args) {
+    if (args.length === 1) {
+        const [length] = args;
+        return (primitive) => lengthGreaterThan(primitive, length);
+    }
+    const [primitive, length] = args;
+    return unwrap.unwrap(primitive).length > unwrap.unwrap(length);
+}
+
+exports.lengthGreaterThan = lengthGreaterThan;

package/dist/clean/primitive/operations/string/lengthGreaterThan.d.ts

@@ -0,0 +1,3 @@
+import { type Number, type String } from "../../base";
+export declare function lengthGreaterThan(length: Number | number): (primitive: String) => boolean;
+export declare function lengthGreaterThan(primitive: String, length: Number | number): boolean;

package/dist/clean/primitive/operations/string/lengthGreaterThan.mjs

@@ -0,0 +1,12 @@
+import { unwrap } from '../../../../common/unwrap.mjs';
+
+function lengthGreaterThan(...args) {
+    if (args.length === 1) {
+        const [length] = args;
+        return (primitive) => lengthGreaterThan(primitive, length);
+    }
+    const [primitive, length] = args;
+    return unwrap(primitive).length > unwrap(length);
+}
+
+export { lengthGreaterThan };

package/dist/clean/primitive/operations/string/lengthLessThan.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var unwrap = require('../../../../common/unwrap.cjs');
+
+function lengthLessThan(...args) {
+    if (args.length === 1) {
+        const [length] = args;
+        return (primitive) => lengthLessThan(primitive, length);
+    }
+    const [primitive, length] = args;
+    return unwrap.unwrap(primitive).length < unwrap.unwrap(length);
+}
+
+exports.lengthLessThan = lengthLessThan;

package/dist/clean/primitive/operations/string/lengthLessThan.d.ts

@@ -0,0 +1,3 @@
+import { type Number, type String } from "../../base";
+export declare function lengthLessThan(length: Number | number): (primitive: String) => boolean;
+export declare function lengthLessThan(primitive: String, length: Number | number): boolean;

package/dist/clean/primitive/operations/string/lengthLessThan.mjs

@@ -0,0 +1,12 @@
+import { unwrap } from '../../../../common/unwrap.mjs';
+
+function lengthLessThan(...args) {
+    if (args.length === 1) {
+        const [length] = args;
+        return (primitive) => lengthLessThan(primitive, length);
+    }
+    const [primitive, length] = args;
+    return unwrap(primitive).length < unwrap(length);
+}
+
+export { lengthLessThan };

package/dist/clean/repository.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var kind = require('./kind.cjs');
+
+const repositoryHandlerKind = kind.createCleanKind("repository-handler");
+function createRepository() {
+    return repositoryHandlerKind.setTo({
+        createImplementation(implementation) {
+            return implementation;
+        },
+    });
+}
+
+exports.createRepository = createRepository;
+exports.repositoryHandlerKind = repositoryHandlerKind;

package/dist/clean/repository.d.ts

@@ -0,0 +1,8 @@
+import { 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;
+}
+export declare function createRepository<GenericRepository extends object>(): RepositoryHandler<GenericRepository>;

package/dist/clean/repository.mjs

@@ -0,0 +1,12 @@
+import { createCleanKind } from './kind.mjs';
+
+const repositoryHandlerKind = createCleanKind("repository-handler");
+function createRepository() {
+    return repositoryHandlerKind.setTo({
+        createImplementation(implementation) {
+            return implementation;
+        },
+    });
+}
+
+export { createRepository, repositoryHandlerKind };

package/dist/clean/useCase.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+var kind = require('./kind.cjs');
+var pipe = require('../common/pipe.cjs');
+var map = require('../array/map.cjs');
+var entry = require('../object/entry.cjs');
+var entries = require('../object/entries.cjs');
+var fromEntries = require('../object/fromEntries.cjs');
+
+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)
+            ? value.getUseCase(repositories)
+            : repositories[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);
+}
+
+exports.createUseCase = createUseCase;
+exports.useCaseHandlerKind = useCaseHandlerKind;
+exports.useCaseInstances = useCaseInstances;

package/dist/clean/useCase.d.ts

@@ -0,0 +1,23 @@
+import { type ObjectEntry, type Kind, type SimplifyTopLevel, type UnionToIntersection } from "../common";
+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;
+}>;
+export type GetAllRepositories<GenericDependenciesValue extends UseCaseDependencies> = GenericDependenciesValue extends any ? ({
+    [Prop in keyof GenericDependenciesValue]: (GenericDependenciesValue[Prop] extends RepositoryHandler ? [
+        Prop,
+        ReturnType<GenericDependenciesValue[Prop]["createImplementation"]>
+    ] : GenericDependenciesValue[Prop] extends UseCaseHandler ? GetAllRepositories<GenericDependenciesValue[Prop]["dependencies"]> : never);
+})[keyof GenericDependenciesValue] : never;
+export declare const useCaseHandlerKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsClean/use-case-handler", unknown>>;
+export interface UseCaseHandler<GenericDependencies extends UseCaseDependencies = any, GenericUseCase extends (input: any) => any = any> extends Kind<typeof useCaseHandlerKind.definition> {
+    dependencies: GenericDependencies;
+    getUseCase(repositories: (GetAllRepositories<GenericDependencies> extends infer InferredEntriesDependenciesValue extends ObjectEntry ? {
+        [Entry in InferredEntriesDependenciesValue as InferredEntriesDependenciesValue[0]]: InferredEntriesDependenciesValue[1];
+    } : never)): GenericUseCase;
+}
+export declare function createUseCase<const GenericDependencies extends UseCaseDependencies, GenericUseCase extends (input: any) => any>(dependencies: GenericDependencies, getUseCase: (dependenciesValue: UseCaseDependenciesValue<GenericDependencies>) => GenericUseCase): UseCaseHandler<GenericDependencies, GenericUseCase>;
+export declare function useCaseInstances<GenericUseCases extends Record<string, UseCaseHandler>>(useCases: GenericUseCases, repositories: SimplifyTopLevel<UnionToIntersection<{
+    [Prop in keyof GenericUseCases]: Parameters<GenericUseCases[Prop]["getUseCase"]>[0];
+}[keyof GenericUseCases]>>): UseCaseDependenciesValue<GenericUseCases>;

package/dist/clean/useCase.mjs

@@ -0,0 +1,21 @@
+import { createCleanKind } from './kind.mjs';
+import { pipe } from '../common/pipe.mjs';
+import { map } from '../array/map.mjs';
+import { entry } from '../object/entry.mjs';
+import { entries } from '../object/entries.mjs';
+import { fromEntries } from '../object/fromEntries.mjs';
+
+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)
+            ? value.getUseCase(repositories)
+            : repositories[key])), fromEntries)),
+    });
+}
+function useCaseInstances(useCases, repositories) {
+    return pipe(useCases, entries, map(([key, useCase]) => entry(key, useCase.getUseCase(repositories))), fromEntries);
+}
+
+export { createUseCase, useCaseHandlerKind, useCaseInstances };

package/dist/common/index.d.ts

@@ -28,7 +28,6 @@ export * from "./forward";
 export * from "./when";
 export * from "./whenNot";
 export * from "./equal";
-export * from "./not";
 export * from "./isType";
 export * from "./and";
 export * from "./or";

package/dist/common/kind.d.ts

@@ -44,6 +44,7 @@ export interface ReservedKindNamespace {
     DuplojsUtilsDataParser: true;
     DuplojsUtilsBuilder: true;
     DuplojsUtilsError: true;
+    DuplojsUtilsClean: true;
 }
 type ForbiddenKindNamespace<GenericValue extends string> = (ForbiddenKindCharacters<GenericValue> & ForbiddenString<GenericValue, GetPropsWithValue<ReservedKindNamespace, true>>);
 export declare function createKindNamespace<GenericNamespace extends string>(namespace: GenericNamespace & ForbiddenKindNamespace<GenericNamespace>): <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & ForbiddenKindCharacters<GenericName>) => KindHandler<KindDefinition<`@${GenericNamespace}/${GenericName}`, GenericKindValue>>;

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

@@ -40,3 +40,4 @@ export * from "./anyPredicate";
 export * from "./removeFromUnion";
 export * from "./unwrapArray";
 export * from "./onlyLiteral";
+export * from "./sortType";

package/dist/common/types/sortType.d.ts

@@ -0,0 +1 @@
+export type SortType = "ASC" | "DSC";

package/dist/common/unwrap.d.ts

@@ -1,4 +1,3 @@
 import { type WrappedValue } from "./wrapValue";
-import { type AnyValue } from "./types/anyValue";
 export type Unwrap<GenericAnyValue extends unknown> = GenericAnyValue extends WrappedValue<infer inferredValue> ? inferredValue : GenericAnyValue;
-export declare function unwrap<GenericValue extends AnyValue, GenericAnyValue extends AnyValue | WrappedValue<GenericValue>>(anyValue: GenericAnyValue): Unwrap<GenericAnyValue>;
+export declare function unwrap<const GenericValue extends unknown>(anyValue: GenericValue): Unwrap<GenericValue>;

package/dist/dataParser/base.d.ts

@@ -1,4 +1,4 @@
-import { type AnyValue, type GetKindHandler, type GetKindValue, type Kind, type KindHandler, type RemoveKind } from "../common";
+import { type GetKindHandler, type GetKindValue, type Kind, type KindHandler, type RemoveKind } from "../common";
 import { SymbolDataParserErrorIssue, SymbolDataParserErrorPromiseIssue, type DataParserError } from "./error";
 import * as DEither from "../either";
 export declare const SymbolDataParserErrorLabel = "SymbolDataParserError";
@@ -8,10 +8,11 @@ export declare const checkerKind: KindHandler<import("../common").KindDefinition
 export interface DataParserCheckerDefinition {
     readonly errorMessage?: string;
 }
-export interface DataParserChecker<GenericDefinition extends DataParserCheckerDefinition = DataParserCheckerDefinition, GenericInput extends AnyValue = AnyValue> extends Kind<typeof checkerKind.definition, GenericInput> {
+export interface DataParserChecker<GenericDefinition extends DataParserCheckerDefinition = DataParserCheckerDefinition, GenericInput extends unknown = unknown> extends Kind<typeof checkerKind.definition, GenericInput> {
     readonly definition: GenericDefinition;
     exec(data: GenericInput, self: this): GenericInput | SymbolDataParserErrorIssue;
 }
+export type InputChecker<GenericDataParser extends DataParserChecker> = Parameters<GenericDataParser["exec"]>[0];
 export declare function dataParserCheckerInit<GenericDataParserChecker extends DataParserChecker>(kind: Exclude<GetKindHandler<GenericDataParserChecker>, typeof checkerKind>, params: NoInfer<Omit<RemoveKind<GenericDataParserChecker>, "exec">>, exec: (...args: Parameters<GenericDataParserChecker["exec"]>) => GetKindValue<typeof checkerKind, GenericDataParserChecker> | SymbolDataParserErrorIssue): GenericDataParserChecker;
 export declare const dataParserKind: KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
     input: unknown;
@@ -19,7 +20,7 @@ export declare const dataParserKind: KindHandler<import("../common").KindDefinit
 }>>;
 export interface DataParserDefinition<GenericChecker extends DataParserChecker = DataParserChecker> {
     readonly errorMessage?: string;
-    readonly checkers: readonly (GenericChecker)[];
+    readonly checkers: readonly GenericChecker[];
 }
 export interface DataParser<GenericDefinition extends DataParserDefinition = DataParserDefinition, GenericOutput extends unknown = unknown, GenericInput extends unknown = GenericOutput> extends Kind<typeof dataParserKind.definition, {
     input: GenericInput;
@@ -39,7 +40,7 @@ interface DataParserInitExecParams<GenericDataParser extends DataParser> {
 }
 export declare function dataParserInit<GenericDataParser extends DataParser>(kind: Exclude<GetKindHandler<GenericDataParser>, typeof dataParserKind>, params: NoInfer<Omit<RemoveKind<GenericDataParser>, "parse" | "exec" | "asyncParse" | "asyncExec" | "addChecker" | "clone">>, exec: (DataParserInitExecParams<GenericDataParser> | DataParserInitExecParams<GenericDataParser>["sync"])): GenericDataParser;
 export declare namespace dataParserInit {
-    var overrideHandler: import("../common").OverrideHandler<DataParser<DataParserDefinition<DataParserChecker<DataParserCheckerDefinition, AnyValue>>, unknown, unknown>>;
+    var overrideHandler: import("../common").OverrideHandler<DataParser<DataParserDefinition<DataParserChecker<DataParserCheckerDefinition, unknown>>, unknown, unknown>>;
 }
 export type Output<GenericDataParser extends DataParser> = GetKindValue<typeof dataParserKind, GenericDataParser>["output"];
 export type Input<GenericDataParser extends DataParser> = GetKindValue<typeof dataParserKind, GenericDataParser>["input"];

package/dist/dataParser/baseExtended.d.ts

@@ -48,6 +48,6 @@ export declare function dataParserExtendedInit<GenericDataParser extends DataPar
     [Prop in Exclude<keyof GenericDataParserExtended, keyof (GenericDataParser & DataParserExtended)>]: GenericDataParserExtended[Prop] extends AnyFunction ? (self: GenericDataParserExtended, ...args: Parameters<GenericDataParserExtended[Prop]>) => ReturnType<GenericDataParserExtended[Prop]> : GenericDataParserExtended[Prop];
 }>): GenericDataParserExtended;
 export declare namespace dataParserExtendedInit {
-    var overrideHandler: import("../common").OverrideHandler<DataParserExtended<DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, AnyValue>>, unknown, unknown>>;
+    var overrideHandler: import("../common").OverrideHandler<DataParserExtended<DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>>;
 }
 export {};

package/dist/dataParser/extended/number.cjs

@@ -15,6 +15,9 @@ function number(definition) {
         max(self, max$1, definition) {
             return self.addChecker(max.checkerNumberMax(max$1, definition));
         },
+        int(self, definition) {
+            return self.addChecker(int$1.checkerInt(definition));
+        },
     });
     return number.overrideHandler.apply(self);
 }

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

@@ -21,6 +21,9 @@ export interface DataParserNumberExtended<GenericDefinition extends dataParsers.
     max(max: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionNumberMax, "max">>): DataParserNumberExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.DataParserCheckerNumberMax
     ]>>;
+    int(definition?: Partial<dataParsers.DataParserCheckerDefinitionInt>): DataParserNumberExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.DataParserCheckerInt
+    ]>>;
 }
 export declare function number<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionNumber> = never>(definition?: GenericDefinition): DataParserNumberExtended<MergeDefinition<dataParsers.DataParserDefinitionNumber, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace number {

package/dist/dataParser/extended/number.mjs

@@ -13,6 +13,9 @@ function number(definition) {
         max(self, max, definition) {
             return self.addChecker(checkerNumberMax(max, definition));
         },
+        int(self, definition) {
+            return self.addChecker(checkerInt(definition));
+        },
     });
     return number.overrideHandler.apply(self);
 }

package/dist/dataParser/extended/object.cjs

@@ -2,23 +2,18 @@
 
 var baseExtended = require('../baseExtended.cjs');
 var index = require('../parsers/object/index.cjs');
-var pipe = require('../../common/pipe.cjs');
-var fromEntries = require('../../object/fromEntries.cjs');
-var filter = require('../../array/filter.cjs');
-var isKeyof = require('../../string/isKeyof.cjs');
-var entries = require('../../object/entries.cjs');
+var required = require('../parsers/object/required.cjs');
+var partial = require('../parsers/object/partial.cjs');
+var pick = require('../parsers/object/pick.cjs');
+var omit = require('../parsers/object/omit.cjs');
 var override = require('../../common/override.cjs');
 
 function object(shape, definition) {
     const self = baseExtended.dataParserExtendedInit(index.object(shape, definition), {
-        omit: (self, omitObject, definition) => {
-            const newShape = pipe.pipe(self.definition.shape, entries.entries, filter.filter(([key]) => !isKeyof.isKeyof(key, omitObject)), fromEntries.fromEntries);
-            return object(newShape, definition);
-        },
-        pick: (self, omitObject, definition) => {
-            const newShape = pipe.pipe(self.definition.shape, entries.entries, filter.filter(([key]) => isKeyof.isKeyof(key, omitObject)), fromEntries.fromEntries);
-            return object(newShape, 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),
     });
     return object.overrideHandler.apply(self);
 }

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

@@ -17,6 +17,8 @@ export interface DataParserObjectExtended<GenericDefinition extends dataParsers.
     ]>>;
     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>>;
 }
 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;

package/dist/dataParser/extended/object.mjs

@@ -1,22 +1,17 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
 import { object as object$1 } from '../parsers/object/index.mjs';
-import { pipe } from '../../common/pipe.mjs';
-import { fromEntries } from '../../object/fromEntries.mjs';
-import { filter } from '../../array/filter.mjs';
-import { isKeyof } from '../../string/isKeyof.mjs';
-import { entries } from '../../object/entries.mjs';
+import { required } from '../parsers/object/required.mjs';
+import { partial } from '../parsers/object/partial.mjs';
+import { pick } from '../parsers/object/pick.mjs';
+import { omit } from '../parsers/object/omit.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 function object(shape, definition) {
     const self = dataParserExtendedInit(object$1(shape, definition), {
-        omit: (self, omitObject, definition) => {
-            const newShape = pipe(self.definition.shape, entries, filter(([key]) => !isKeyof(key, omitObject)), fromEntries);
-            return object(newShape, definition);
-        },
-        pick: (self, omitObject, definition) => {
-            const newShape = pipe(self.definition.shape, entries, filter(([key]) => isKeyof(key, omitObject)), fromEntries);
-            return object(newShape, definition);
-        },
+        omit: (self, omitObject, definition) => omit(self, omitObject, definition),
+        pick: (self, pickObject, definition) => pick(self, pickObject, definition),
+        partial: (self, definition) => partial(self, definition),
+        required: (self, definition) => required(self, definition),
     });
     return object.overrideHandler.apply(self);
 }