@duplojs/utils 1.2.17 → 1.2.19

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

@@ -1,9 +1,9 @@
-import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
 import { type Output } from "../base";
-type _DataParserObjectExtended<GenericDefinition extends dataParsers.DataParserDefinitionObject> = (dataParsers.DataParserObject<GenericDefinition> & DataParserExtended);
+type _DataParserObjectExtended<GenericDefinition extends dataParsers.DataParserDefinitionObject> = (Kind<typeof dataParsers.objectKind.definition> & DataParserExtended<GenericDefinition, dataParsers.DataParserObjectShapeOutput<GenericDefinition["shape"]>, dataParsers.DataParserObjectShapeInput<GenericDefinition["shape"]>>);
 export interface DataParserObjectExtended<GenericDefinition extends dataParsers.DataParserDefinitionObject = dataParsers.DataParserDefinitionObject> extends _DataParserObjectExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserObjectCheckers<Output<this>>,
@@ -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);
 }

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

@@ -1,9 +1,9 @@
-import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type IsEqual, type Kind, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output, type DataParser } from "../base";
-type _DataParserOptionalExtended<GenericDefinition extends dataParsers.DataParserDefinitionOptional> = (dataParsers.DataParserOptional<GenericDefinition> & DataParserExtended);
+import { type Input, type Output, type DataParser } from "../base";
+type _DataParserOptionalExtended<GenericDefinition extends dataParsers.DataParserDefinitionOptional> = (Kind<typeof dataParsers.optionalKind.definition> & DataParserExtended<GenericDefinition, IsEqual<GenericDefinition["coalescingValue"], unknown> extends true ? Output<GenericDefinition["inner"]> | undefined : Output<GenericDefinition["inner"]>, Input<GenericDefinition["inner"]> | undefined>);
 export interface DataParserOptionalExtended<GenericDefinition extends dataParsers.DataParserDefinitionOptional = dataParsers.DataParserDefinitionOptional> extends _DataParserOptionalExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserOptionalCheckers<Output<this>>,

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

@@ -1,9 +1,9 @@
-import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output, type DataParser } from "../base";
-type _DataParserPipeExtended<GenericDefinition extends dataParsers.DataParserDefinitionPipe> = (dataParsers.DataParserPipe<GenericDefinition> & DataParserExtended);
+import { type Input, type Output, type DataParser } from "../base";
+type _DataParserPipeExtended<GenericDefinition extends dataParsers.DataParserDefinitionPipe> = (Kind<typeof dataParsers.pipeKind.definition> & DataParserExtended<GenericDefinition, Output<GenericDefinition["output"]>, Input<GenericDefinition["input"]>>);
 export interface DataParserPipeExtended<GenericDefinition extends dataParsers.DataParserDefinitionPipe = dataParsers.DataParserDefinitionPipe> extends _DataParserPipeExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserPipeCheckers<Output<this>>,

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

@@ -1,9 +1,9 @@
-import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output, type DataParser } from "../base";
-type _DataParserRecordExtended<GenericDefinition extends dataParsers.DataParserDefinitionRecord> = (dataParsers.DataParserRecord<GenericDefinition> & DataParserExtended);
+import { type Input, type Output, type DataParser } from "../base";
+type _DataParserRecordExtended<GenericDefinition extends dataParsers.DataParserDefinitionRecord> = (Kind<typeof dataParsers.recordKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserRecord<GenericDefinition>>, Input<dataParsers.DataParserRecord<GenericDefinition>>>);
 export interface DataParserRecordExtended<GenericDefinition extends dataParsers.DataParserDefinitionRecord = dataParsers.DataParserDefinitionRecord> extends _DataParserRecordExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserRecordCheckers<Output<this>>,

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

@@ -1,9 +1,9 @@
-import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output, type DataParser } from "../base";
-type _DataParserRecoverExtended<GenericDefinition extends dataParsers.DataParserDefinitionRecover> = (dataParsers.DataParserRecover<GenericDefinition> & DataParserExtended);
+import { type Input, type Output, type DataParser } from "../base";
+type _DataParserRecoverExtended<GenericDefinition extends dataParsers.DataParserDefinitionRecover> = (Kind<typeof dataParsers.recoverKind.definition> & DataParserExtended<GenericDefinition, GenericDefinition["recoveredValue"], Input<GenericDefinition["inner"]>>);
 export interface DataParserRecoverExtended<GenericDefinition extends dataParsers.DataParserDefinitionRecover = dataParsers.DataParserDefinitionRecover> extends _DataParserRecoverExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserRecoverCheckers<Output<this>>,

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

@@ -1,9 +1,9 @@
-import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
 import { type Output } from "../base";
-type _DataParserStringExtended<GenericDefinition extends dataParsers.DataParserDefinitionString> = (dataParsers.DataParserString<GenericDefinition> & DataParserExtended);
+type _DataParserStringExtended<GenericDefinition extends dataParsers.DataParserDefinitionString> = (Kind<typeof dataParsers.stringKind.definition> & DataParserExtended<GenericDefinition, string, string>);
 export interface DataParserStringExtended<GenericDefinition extends dataParsers.DataParserDefinitionString = dataParsers.DataParserDefinitionString> extends _DataParserStringExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserStringCheckers,

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

@@ -1,9 +1,9 @@
-import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
 import { type Output } from "../base";
-type _DataParserTemplateLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionTemplateLiteral> = (dataParsers.DataParserTemplateLiteral<GenericDefinition> & DataParserExtended);
+type _DataParserTemplateLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionTemplateLiteral> = (Kind<typeof dataParsers.templateLiteralKind.definition> & DataParserExtended<GenericDefinition, dataParsers.TemplateLiteralShapeOutput<GenericDefinition["template"]>, dataParsers.TemplateLiteralShapeInput<GenericDefinition["template"]>>);
 export interface DataParserTemplateLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionTemplateLiteral = dataParsers.DataParserDefinitionTemplateLiteral> extends _DataParserTemplateLiteralExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserTemplateLiteralCheckers<Output<this>>,

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

@@ -1,10 +1,10 @@
-import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type DataParser, type Output } from "../base";
+import { type DataParser, type Input, type Output } from "../base";
 import { type DataParserError } from "../error";
-type _DataParserTransformExtended<GenericDefinition extends dataParsers.DataParserDefinitionTransform> = (dataParsers.DataParserTransform<GenericDefinition> & DataParserExtended);
+type _DataParserTransformExtended<GenericDefinition extends dataParsers.DataParserDefinitionTransform> = (Kind<typeof dataParsers.transformKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserTransform<GenericDefinition>>, Input<GenericDefinition["inner"]>>);
 export interface DataParserTransformExtended<GenericDefinition extends dataParsers.DataParserDefinitionTransform = dataParsers.DataParserDefinitionTransform> extends _DataParserTransformExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserTransformCheckers<Output<this>>,

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

@@ -1,9 +1,9 @@
-import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output } from "../base";
-type _DataParserTupleExtended<GenericDefinition extends dataParsers.DataParserDefinitionTuple> = (dataParsers.DataParserTuple<GenericDefinition> & DataParserExtended);
+import { type Input, type Output } from "../base";
+type _DataParserTupleExtended<GenericDefinition extends dataParsers.DataParserDefinitionTuple> = (Kind<typeof dataParsers.tupleKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserTuple<GenericDefinition>>, Input<dataParsers.DataParserTuple<GenericDefinition>>>);
 export interface DataParserTupleExtended<GenericDefinition extends dataParsers.DataParserDefinitionTuple = dataParsers.DataParserDefinitionTuple> extends _DataParserTupleExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserTupleCheckers<Output<this>>,

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

@@ -1,9 +1,9 @@
-import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output } from "../base";
-type _DataParserUnionExtended<GenericDefinition extends dataParsers.DataParserDefinitionUnion> = (dataParsers.DataParserUnion<GenericDefinition> & DataParserExtended);
+import { type Input, type Output } from "../base";
+type _DataParserUnionExtended<GenericDefinition extends dataParsers.DataParserDefinitionUnion> = (Kind<typeof dataParsers.unionKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserUnion<GenericDefinition>>, Input<dataParsers.DataParserUnion<GenericDefinition>>>);
 export interface DataParserUnionExtended<GenericDefinition extends dataParsers.DataParserDefinitionUnion = dataParsers.DataParserDefinitionUnion> extends _DataParserUnionExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserUnionCheckers<Output<this>>,

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

@@ -1,9 +1,9 @@
-import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
 import { type Output } from "../base";
-type _DataParserUnknownExtended<GenericDefinition extends dataParsers.DataParserDefinitionUnknown> = (dataParsers.DataParserUnknown<GenericDefinition> & DataParserExtended);
+type _DataParserUnknownExtended<GenericDefinition extends dataParsers.DataParserDefinitionUnknown> = (Kind<typeof dataParsers.unknownKind.definition> & DataParserExtended<GenericDefinition, unknown, unknown>);
 export interface DataParserUnknownExtended<GenericDefinition extends dataParsers.DataParserDefinitionUnknown = dataParsers.DataParserDefinitionUnknown> extends _DataParserUnknownExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserUnknownCheckers,