@duplojs/utils 1.1.16 → 1.2.17

package/dist/dataParser/parsers/date.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var base = require('../base.cjs');
+var error = require('../error.cjs');
+var kind = require('../kind.cjs');
+var isSafeTimestamp = require('../../date/isSafeTimestamp.cjs');
+var constants = require('../../date/constants.cjs');
+var override = require('../../common/override.cjs');
+
+const dateKind = kind.createDataParserKind("date");
+function date(definition) {
+    const self = base.dataParserInit(dateKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            coerce: definition?.coerce ?? false,
+        },
+    }, (data, _error, self) => {
+        if (self.definition.coerce) {
+            if (data instanceof Date) {
+                const timestamp = data.getTime();
+                if (!isSafeTimestamp.isSafeTimestamp(timestamp)) {
+                    return error.SymbolDataParserErrorIssue;
+                }
+                const isNegative = timestamp < 0;
+                return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+            }
+            if (typeof data === "number") {
+                if (!isSafeTimestamp.isSafeTimestamp(data)) {
+                    return error.SymbolDataParserErrorIssue;
+                }
+                const isNegative = data < 0;
+                return `date${Math.abs(data)}${isNegative ? "-" : "+"}`;
+            }
+        }
+        const theDateMatch = typeof data === "string" && data.match(constants.theDateRegex);
+        if (theDateMatch) {
+            if (!isSafeTimestamp.isSafeTimestamp(Number(theDateMatch.groups?.value))) {
+                return error.SymbolDataParserErrorIssue;
+            }
+            return data;
+        }
+        return error.SymbolDataParserErrorIssue;
+    });
+    return date.overrideHandler.apply(self);
+}
+date.overrideHandler = override.createOverride("@duplojs/utils/data-parser/date");
+
+exports.date = date;
+exports.dateKind = dateKind;

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

@@ -0,0 +1,28 @@
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer } from "../../common";
+import { type DataParserDefinition, type DataParser, type DataParserChecker } from "../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
+import { type CheckerRefineImplementation } from "./refine";
+import { type GetPropsWithValueExtends } from "../../object";
+import { type TheDate } from "../../date";
+export interface DataParserDateCheckerCustom {
+}
+export type DataParserDateCheckers = (DataParserDateCheckerCustom[GetPropsWithValueExtends<DataParserDateCheckerCustom, DataParserChecker>] | CheckerRefineImplementation<TheDate>);
+export interface DataParserDefinitionDate extends DataParserDefinition<DataParserDateCheckers> {
+    readonly coerce: boolean;
+}
+export declare const dateKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/date", unknown>>;
+type _DataParserDate<GenericDefinition extends DataParserDefinitionDate> = (DataParser<GenericDefinition, TheDate, TheDate> & Kind<typeof dateKind.definition>);
+export interface DataParserDate<GenericDefinition extends DataParserDefinitionDate = DataParserDefinitionDate> extends _DataParserDate<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserDateCheckers,
+        ...DataParserDateCheckers[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserDateCheckers,
+        ...DataParserDateCheckers[]
+    ], GenericChecker>): DataParserDate<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+}
+export declare function date<const GenericDefinition extends Partial<DataParserDefinitionDate> = never>(definition?: GenericDefinition): DataParserDate<MergeDefinition<DataParserDefinitionDate, NeverCoalescing<GenericDefinition, {}>>>;
+export declare namespace date {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserDate<DataParserDefinitionDate>>;
+}
+export {};

package/dist/dataParser/parsers/date.mjs

@@ -0,0 +1,47 @@
+import { dataParserInit } from '../base.mjs';
+import { SymbolDataParserErrorIssue } from '../error.mjs';
+import { createDataParserKind } from '../kind.mjs';
+import { isSafeTimestamp } from '../../date/isSafeTimestamp.mjs';
+import { theDateRegex } from '../../date/constants.mjs';
+import { createOverride } from '../../common/override.mjs';
+
+const dateKind = createDataParserKind("date");
+function date(definition) {
+    const self = dataParserInit(dateKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            coerce: definition?.coerce ?? false,
+        },
+    }, (data, _error, self) => {
+        if (self.definition.coerce) {
+            if (data instanceof Date) {
+                const timestamp = data.getTime();
+                if (!isSafeTimestamp(timestamp)) {
+                    return SymbolDataParserErrorIssue;
+                }
+                const isNegative = timestamp < 0;
+                return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+            }
+            if (typeof data === "number") {
+                if (!isSafeTimestamp(data)) {
+                    return SymbolDataParserErrorIssue;
+                }
+                const isNegative = data < 0;
+                return `date${Math.abs(data)}${isNegative ? "-" : "+"}`;
+            }
+        }
+        const theDateMatch = typeof data === "string" && data.match(theDateRegex);
+        if (theDateMatch) {
+            if (!isSafeTimestamp(Number(theDateMatch.groups?.value))) {
+                return SymbolDataParserErrorIssue;
+            }
+            return data;
+        }
+        return SymbolDataParserErrorIssue;
+    });
+    return date.overrideHandler.apply(self);
+}
+date.overrideHandler = createOverride("@duplojs/utils/data-parser/date");
+
+export { date, dateKind };

package/dist/dataParser/parsers/empty.cjs

@@ -3,10 +3,11 @@
 var base = require('../base.cjs');
 var error = require('../error.cjs');
 var kind = require('../kind.cjs');
+var override = require('../../common/override.cjs');
 
 const emptyKind = kind.createDataParserKind("empty");
 function empty(definition) {
-    return base.dataParserInit(emptyKind, {
+    const self = base.dataParserInit(emptyKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -21,7 +22,9 @@ function empty(definition) {
         }
         return error.SymbolDataParserErrorIssue;
     });
+    return empty.overrideHandler.apply(self);
 }
+empty.overrideHandler = override.createOverride("@duplojs/utils/data-parser/empty");
 
 exports.empty = empty;
 exports.emptyKind = emptyKind;

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

@@ -21,4 +21,7 @@ export interface DataParserEmpty<GenericDefinition extends DataParserDefinitionE
     ], GenericChecker>): DataParserEmpty<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function empty<const GenericDefinition extends Partial<DataParserDefinitionEmpty> = never>(definition?: GenericDefinition): DataParserEmpty<MergeDefinition<DataParserDefinitionEmpty, NeverCoalescing<GenericDefinition, {}>>>;
+export declare namespace empty {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserEmpty<DataParserDefinitionEmpty>>;
+}
 export {};

package/dist/dataParser/parsers/empty.mjs

@@ -1,10 +1,11 @@
 import { dataParserInit } from '../base.mjs';
 import { SymbolDataParserErrorIssue } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 const emptyKind = createDataParserKind("empty");
 function empty(definition) {
-    return dataParserInit(emptyKind, {
+    const self = dataParserInit(emptyKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -19,6 +20,8 @@ function empty(definition) {
         }
         return SymbolDataParserErrorIssue;
     });
+    return empty.overrideHandler.apply(self);
 }
+empty.overrideHandler = createOverride("@duplojs/utils/data-parser/empty");
 
 export { empty, emptyKind };

package/dist/dataParser/parsers/index.d.ts

@@ -2,6 +2,7 @@ export * as coerce from "./coerce";
 export * from "./string";
 export * from "./object";
 export * from "./number";
+export * from "./date";
 export * from "./literal";
 export * from "./union";
 export * from "./array";

package/dist/dataParser/parsers/lazy.cjs

@@ -1,14 +1,13 @@
 'use strict';
 
-var memo = require('../../common/memo.cjs');
-require('../../common/globalStore.cjs');
-require('../../common/builder.cjs');
 var base = require('../base.cjs');
 var kind = require('../kind.cjs');
+var memo = require('../../common/memo.cjs');
+var override = require('../../common/override.cjs');
 
 const lazyKind = kind.createDataParserKind("lazy");
 function lazy(getter, definition) {
-    return base.dataParserInit(lazyKind, {
+    const self = base.dataParserInit(lazyKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -18,7 +17,9 @@ function lazy(getter, definition) {
         sync: (data, _error, self) => self.definition.getter.value.exec(data, _error),
         async: (data, _error, self) => self.definition.getter.value.asyncExec(data, _error),
     });
+    return lazy.overrideHandler.apply(self);
 }
+lazy.overrideHandler = override.createOverride("@duplojs/utils/data-parser/lazy");
 
 exports.lazy = lazy;
 exports.lazyKind = lazyKind;

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

@@ -23,4 +23,7 @@ export interface DataParserLazy<GenericDefinition extends DataParserDefinitionLa
 export declare function lazy<GenericDataParser extends DataParser, const GenericDefinition extends Partial<DataParserDefinitionLazy> = never>(getter: () => GenericDataParser, definition?: GenericDefinition): DataParserLazy<MergeDefinition<DataParserDefinitionLazy, NeverCoalescing<GenericDefinition, {}> & {
     getter: Memoized<GenericDataParser>;
 }>>;
+export declare namespace lazy {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserLazyCheckerCustom<unknown>>;
+}
 export {};

package/dist/dataParser/parsers/lazy.mjs

@@ -1,12 +1,11 @@
-import { memo } from '../../common/memo.mjs';
-import '../../common/globalStore.mjs';
-import '../../common/builder.mjs';
 import { dataParserInit } from '../base.mjs';
 import { createDataParserKind } from '../kind.mjs';
+import { memo } from '../../common/memo.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 const lazyKind = createDataParserKind("lazy");
 function lazy(getter, definition) {
-    return dataParserInit(lazyKind, {
+    const self = dataParserInit(lazyKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -16,6 +15,8 @@ function lazy(getter, definition) {
         sync: (data, _error, self) => self.definition.getter.value.exec(data, _error),
         async: (data, _error, self) => self.definition.getter.value.asyncExec(data, _error),
     });
+    return lazy.overrideHandler.apply(self);
 }
+lazy.overrideHandler = createOverride("@duplojs/utils/data-parser/lazy");
 
 export { lazy, lazyKind };

package/dist/dataParser/parsers/literal.cjs

@@ -2,14 +2,13 @@
 
 var base = require('../base.cjs');
 var error = require('../error.cjs');
-require('../../common/globalStore.cjs');
-require('../../common/builder.cjs');
-var coalescing = require('../../array/coalescing.cjs');
 var kind = require('../kind.cjs');
+var coalescing = require('../../array/coalescing.cjs');
+var override = require('../../common/override.cjs');
 
 const literalKind = kind.createDataParserKind("literal");
 function literal(value, definition) {
-    return base.dataParserInit(literalKind, {
+    const self = base.dataParserInit(literalKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -21,7 +20,9 @@ function literal(value, definition) {
         }
         return error.SymbolDataParserErrorIssue;
     });
+    return literal.overrideHandler.apply(self);
 }
+literal.overrideHandler = override.createOverride("@duplojs/utils/data-parser/literal");
 
 exports.literal = literal;
 exports.literalKind = literalKind;

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

@@ -24,4 +24,7 @@ export interface DataParserLiteral<GenericDefinition extends DataParserDefinitio
 export declare function literal<const GenericValue extends LiteralValue, const GenericDefinition extends Partial<Omit<DataParserDefinitionLiteral, "value">> = never>(value: GenericValue | GenericValue[], definition?: GenericDefinition): DataParserLiteral<MergeDefinition<DataParserDefinitionLiteral, NeverCoalescing<GenericDefinition, {}> & {
     value: GenericValue[];
 }>>;
+export declare namespace literal {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserLiteral<DataParserDefinitionLiteral>>;
+}
 export {};

package/dist/dataParser/parsers/literal.mjs

@@ -1,13 +1,12 @@
 import { dataParserInit } from '../base.mjs';
 import { SymbolDataParserErrorIssue } from '../error.mjs';
-import '../../common/globalStore.mjs';
-import '../../common/builder.mjs';
-import { coalescing } from '../../array/coalescing.mjs';
 import { createDataParserKind } from '../kind.mjs';
+import { coalescing } from '../../array/coalescing.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 const literalKind = createDataParserKind("literal");
 function literal(value, definition) {
-    return dataParserInit(literalKind, {
+    const self = dataParserInit(literalKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -19,6 +18,8 @@ function literal(value, definition) {
         }
         return SymbolDataParserErrorIssue;
     });
+    return literal.overrideHandler.apply(self);
 }
+literal.overrideHandler = createOverride("@duplojs/utils/data-parser/literal");
 
 export { literal, literalKind };

package/dist/dataParser/parsers/nil.cjs

@@ -3,10 +3,11 @@
 var base = require('../base.cjs');
 var error = require('../error.cjs');
 var kind = require('../kind.cjs');
+var override = require('../../common/override.cjs');
 
 const nilKind = kind.createDataParserKind("nil");
 function nil(definition) {
-    return base.dataParserInit(nilKind, {
+    const self = base.dataParserInit(nilKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -21,7 +22,9 @@ function nil(definition) {
         }
         return error.SymbolDataParserErrorIssue;
     });
+    return nil.overrideHandler.apply(self);
 }
+nil.overrideHandler = override.createOverride("@duplojs/utils/data-parser/nil");
 
 exports.nil = nil;
 exports.nilKind = nilKind;

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

@@ -21,4 +21,7 @@ export interface DataParserNil<GenericDefinition extends DataParserDefinitionNil
     ], GenericChecker>): DataParserNil<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function nil<const GenericDefinition extends Partial<DataParserDefinitionNil> = never>(definition?: GenericDefinition): DataParserNil<MergeDefinition<DataParserDefinitionNil, NeverCoalescing<GenericDefinition, {}>>>;
+export declare namespace nil {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserNil<DataParserDefinitionNil>>;
+}
 export {};

package/dist/dataParser/parsers/nil.mjs

@@ -1,10 +1,11 @@
 import { dataParserInit } from '../base.mjs';
 import { SymbolDataParserErrorIssue } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 const nilKind = createDataParserKind("nil");
 function nil(definition) {
-    return dataParserInit(nilKind, {
+    const self = dataParserInit(nilKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -19,6 +20,8 @@ function nil(definition) {
         }
         return SymbolDataParserErrorIssue;
     });
+    return nil.overrideHandler.apply(self);
 }
+nil.overrideHandler = createOverride("@duplojs/utils/data-parser/nil");
 
 export { nil, nilKind };

package/dist/dataParser/parsers/nullable.cjs

@@ -2,10 +2,11 @@
 
 var base = require('../base.cjs');
 var kind = require('../kind.cjs');
+var override = require('../../common/override.cjs');
 
 const nullableKind = kind.createDataParserKind("nullable");
 function nullable(inner, definition) {
-    return base.dataParserInit(nullableKind, {
+    const self = base.dataParserInit(nullableKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -26,7 +27,9 @@ function nullable(inner, definition) {
             return self.definition.inner.asyncExec(data, error);
         },
     });
+    return nullable.overrideHandler.apply(self);
 }
+nullable.overrideHandler = override.createOverride("@duplojs/utils/data-parser/nullable");
 
 exports.nullable = nullable;
 exports.nullableKind = nullableKind;

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

@@ -24,4 +24,7 @@ export interface DataParserNullable<GenericDefinition extends DataParserDefiniti
 export declare function nullable<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionNullable<Output<GenericDataParser> | null>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullable<MergeDefinition<DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
+export declare namespace nullable {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserNullable<DataParserDefinitionNullable<unknown>>>;
+}
 export {};

package/dist/dataParser/parsers/nullable.mjs

@@ -1,9 +1,10 @@
 import { dataParserInit } from '../base.mjs';
 import { createDataParserKind } from '../kind.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 const nullableKind = createDataParserKind("nullable");
 function nullable(inner, definition) {
-    return dataParserInit(nullableKind, {
+    const self = dataParserInit(nullableKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -24,6 +25,8 @@ function nullable(inner, definition) {
             return self.definition.inner.asyncExec(data, error);
         },
     });
+    return nullable.overrideHandler.apply(self);
 }
+nullable.overrideHandler = createOverride("@duplojs/utils/data-parser/nullable");
 
 export { nullable, nullableKind };

package/dist/dataParser/parsers/number/index.cjs

@@ -3,10 +3,11 @@
 var base = require('../../base.cjs');
 var error = require('../../error.cjs');
 var kind = require('../../kind.cjs');
+var override = require('../../../common/override.cjs');
 
 const numberKind = kind.createDataParserKind("number");
 function number(definition) {
-    return base.dataParserInit(numberKind, {
+    const self = base.dataParserInit(numberKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -25,7 +26,9 @@ function number(definition) {
         }
         return error.SymbolDataParserErrorIssue;
     });
+    return number.overrideHandler.apply(self);
 }
+number.overrideHandler = override.createOverride("@duplojs/utils/data-parser/number");
 
 exports.number = number;
 exports.numberKind = numberKind;

package/dist/dataParser/parsers/number/index.d.ts

@@ -23,3 +23,6 @@ export interface DataParserNumber<GenericDefinition extends DataParserDefinition
     ], GenericChecker>): DataParserNumber<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function number<const GenericDefinition extends Partial<DataParserDefinitionNumber> = never>(definition?: GenericDefinition): DataParserNumber<MergeDefinition<DataParserDefinitionNumber, NeverCoalescing<GenericDefinition, {}>>>;
+export declare namespace number {
+    var overrideHandler: import("../../../common").OverrideHandler<DataParserNumber<DataParserDefinitionNumber>>;
+}

package/dist/dataParser/parsers/number/index.mjs

@@ -1,10 +1,11 @@
 import { dataParserInit } from '../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../error.mjs';
 import { createDataParserKind } from '../../kind.mjs';
+import { createOverride } from '../../../common/override.mjs';
 
 const numberKind = createDataParserKind("number");
 function number(definition) {
-    return dataParserInit(numberKind, {
+    const self = dataParserInit(numberKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -23,6 +24,8 @@ function number(definition) {
         }
         return SymbolDataParserErrorIssue;
     });
+    return number.overrideHandler.apply(self);
 }
+number.overrideHandler = createOverride("@duplojs/utils/data-parser/number");
 
 export { number, numberKind };

package/dist/dataParser/parsers/{object.cjs → object/index.cjs}

@@ -1,20 +1,19 @@
 'use strict';
 
-var entries = require('../../object/entries.cjs');
-var pipe = require('../../common/pipe.cjs');
-var forward = require('../../common/forward.cjs');
-var memo = require('../../common/memo.cjs');
-var filter = require('../../array/filter.cjs');
-var map = require('../../array/map.cjs');
-require('../../common/globalStore.cjs');
-require('../../common/builder.cjs');
-var base = require('../base.cjs');
-var error = require('../error.cjs');
-var kind = require('../kind.cjs');
+var base = require('../../base.cjs');
+var error = require('../../error.cjs');
+var kind = require('../../kind.cjs');
+var memo = require('../../../common/memo.cjs');
+var forward = require('../../../common/forward.cjs');
+var pipe = require('../../../common/pipe.cjs');
+var map = require('../../../array/map.cjs');
+var filter = require('../../../array/filter.cjs');
+var entries = require('../../../object/entries.cjs');
+var override = require('../../../common/override.cjs');
 
 const objectKind = kind.createDataParserKind("object");
 function object(shape, definition) {
-    return base.dataParserInit(objectKind, {
+    const self = base.dataParserInit(objectKind, {
         definition: {
             shape,
             errorMessage: definition?.errorMessage,
@@ -70,7 +69,9 @@ function object(shape, definition) {
             return output;
         },
     });
+    return object.overrideHandler.apply(self);
 }
+object.overrideHandler = override.createOverride("@duplojs/utils/data-parser/object");
 
 exports.object = object;
 exports.objectKind = objectKind;

package/dist/dataParser/parsers/{object.d.ts → object/index.d.ts}

@@ -1,14 +1,16 @@
-import { type Kind, type IsEqual, type NeverCoalescing, type Memoized, type FixDeepFunctionInfer } from "../../common";
-import { dataParserKind, type Input, type Output, type DataParser, type DataParserDefinition, type DataParserChecker } from "../base";
-import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
-import * as DObject from "../../object";
-import { type GetPropsWithValueExtends } from "../../object";
-import { type CheckerRefineImplementation } from "./refine";
+import { type Kind, type NeverCoalescing, type Memoized, type FixDeepFunctionInfer } from "../../../common";
+import { dataParserKind, type Input, type Output, type DataParser, type DataParserDefinition, type DataParserChecker } from "../../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../types";
+import * as DObject from "../../../object";
+import { type GetPropsWithValueExtends } from "../../../object";
+import { type CheckerRefineImplementation } from "../refine";
+export * from "./omit";
+export * from "./pick";
 export type DataParserObjectShape = Readonly<Record<string, DataParser>>;
-export type DataParserObjectShapeOutput<GenericShape extends DataParserObjectShape> = IsEqual<GenericShape, DataParserObjectShape> extends true ? DataParserObjectShape : {
+export type DataParserObjectShapeOutput<GenericShape extends DataParserObjectShape> = {
     -readonly [Prop in keyof GenericShape as GenericShape[Prop] extends Kind<typeof dataParserKind.definition> ? Prop : never]: Output<GenericShape[Prop]>;
 } extends infer InferredResult extends object ? DObject.PartialKeys<InferredResult, DObject.GetPropsWithValueExtends<InferredResult, undefined>> : never;
-export type DataParserObjectShapeInput<GenericShape extends DataParserObjectShape> = IsEqual<GenericShape, DataParserObjectShape> extends true ? DataParserObjectShape : {
+export type DataParserObjectShapeInput<GenericShape extends DataParserObjectShape> = {
     -readonly [Prop in keyof GenericShape as GenericShape[Prop] extends Kind<typeof dataParserKind.definition> ? Prop : never]: Input<GenericShape[Prop]>;
 } extends infer InferredResult extends object ? DObject.PartialKeys<InferredResult, DObject.GetPropsWithValueExtends<InferredResult, undefined>> : never;
 export interface DataParserObjectCheckerCustom<GenericInput extends DataParserObjectShape = DataParserObjectShape> {
@@ -21,7 +23,7 @@ export interface DataParserDefinitionObject extends DataParserDefinition<DataPar
         readonly value: DataParser;
     }[]>;
 }
-export declare const objectKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/object", unknown>>;
+export declare const objectKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/object", unknown>>;
 type _DataParserObject<GenericDefinition extends DataParserDefinitionObject> = (DataParser<GenericDefinition, DataParserObjectShapeOutput<GenericDefinition["shape"]>, DataParserObjectShapeInput<GenericDefinition["shape"]>> & Kind<typeof objectKind.definition>);
 export interface DataParserObject<GenericDefinition extends DataParserDefinitionObject = DataParserDefinitionObject> extends _DataParserObject<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
@@ -32,7 +34,9 @@ export interface DataParserObject<GenericDefinition extends DataParserDefinition
         ...DataParserObjectCheckers<Output<this>>[]
     ], GenericChecker>): DataParserObject<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
-export declare function object<const GenericShape extends DataParserObjectShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
-    shape: GenericShape;
+export declare function object<const GenericShape extends DataParserObjectShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
+    readonly shape: GenericShape;
 }>>;
-export {};
+export declare namespace object {
+    var overrideHandler: import("../../../common").OverrideHandler<DataParserObject<DataParserDefinitionObject>>;
+}

package/dist/dataParser/parsers/{object.mjs → object/index.mjs}

@@ -1,18 +1,17 @@
-import { entries } from '../../object/entries.mjs';
-import { pipe } from '../../common/pipe.mjs';
-import { forward } from '../../common/forward.mjs';
-import { memo } from '../../common/memo.mjs';
-import { filter } from '../../array/filter.mjs';
-import { map } from '../../array/map.mjs';
-import '../../common/globalStore.mjs';
-import '../../common/builder.mjs';
-import { dataParserInit, SymbolDataParserError, dataParserKind } from '../base.mjs';
-import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../error.mjs';
-import { createDataParserKind } from '../kind.mjs';
+import { dataParserInit, SymbolDataParserError, dataParserKind } from '../../base.mjs';
+import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../../error.mjs';
+import { createDataParserKind } from '../../kind.mjs';
+import { memo } from '../../../common/memo.mjs';
+import { forward } from '../../../common/forward.mjs';
+import { pipe } from '../../../common/pipe.mjs';
+import { map } from '../../../array/map.mjs';
+import { filter } from '../../../array/filter.mjs';
+import { entries } from '../../../object/entries.mjs';
+import { createOverride } from '../../../common/override.mjs';
 
 const objectKind = createDataParserKind("object");
 function object(shape, definition) {
-    return dataParserInit(objectKind, {
+    const self = dataParserInit(objectKind, {
         definition: {
             shape,
             errorMessage: definition?.errorMessage,
@@ -68,6 +67,8 @@ function object(shape, definition) {
             return output;
         },
     });
+    return object.overrideHandler.apply(self);
 }
+object.overrideHandler = createOverride("@duplojs/utils/data-parser/object");
 
 export { object, objectKind };

package/dist/dataParser/parsers/object/omit.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var index = require('./index.cjs');
+var pipe = require('../../../common/pipe.cjs');
+var filter = require('../../../array/filter.cjs');
+var isKeyof = require('../../../string/isKeyof.cjs');
+var entries = require('../../../object/entries.cjs');
+var fromEntries = require('../../../object/fromEntries.cjs');
+
+function omit(dataParser, omitObject, definition) {
+    const newShape = pipe.pipe(dataParser.definition.shape, entries.entries, filter.filter(([key]) => !isKeyof.isKeyof(key, omitObject)), fromEntries.fromEntries);
+    return index.object(newShape, definition);
+}
+
+exports.omit = omit;

package/dist/dataParser/parsers/object/omit.d.ts

@@ -0,0 +1,6 @@
+import { type MergeDefinition } from "../../../dataParser/types";
+import { type DataParserDefinitionObject, type DataParserObject } from ".";
+import { type SimplifyTopLevel, type NeverCoalescing } from "../../../common";
+export declare function omit<GenericDataParserObject extends DataParserObject, const GenericOmitObject extends Partial<Record<keyof GenericDataParserObject["definition"]["shape"], true>>, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, omitObject: GenericOmitObject, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
+    readonly shape: SimplifyTopLevel<Omit<GenericDataParserObject["definition"]["shape"], keyof GenericOmitObject>>;
+}>>;