@duplojs/utils 1.1.13 → 1.1.14

package/dist/dataParser/parsers/number/checkers/min.cjs

@@ -4,9 +4,9 @@ var base = require('../../../base.cjs');
 var error = require('../../../error.cjs');
 var kind = require('../../../kind.cjs');
 
-const dataParserCheckerNumberMinKind = kind.createDataParserKind("checker-number-min");
+const checkerNumberMinKind = kind.createDataParserKind("checker-number-min");
 function checkerNumberMin(min, definition = {}) {
-    return base.dataParserCheckerInit(dataParserCheckerNumberMinKind, {
+    return base.dataParserCheckerInit(checkerNumberMinKind, {
         definition: {
             ...definition,
             min,
@@ -15,4 +15,4 @@ function checkerNumberMin(min, definition = {}) {
 }
 
 exports.checkerNumberMin = checkerNumberMin;
-exports.dataParserCheckerNumberMinKind = dataParserCheckerNumberMinKind;
+exports.checkerNumberMinKind = checkerNumberMinKind;

package/dist/dataParser/parsers/number/checkers/min.d.ts

@@ -3,8 +3,8 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionNumberMin extends DataParserCheckerDefinition {
     min: number;
 }
-export declare const dataParserCheckerNumberMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-number-min", unknown>>;
-type _DataParserCheckerNumberMin = (Kind<typeof dataParserCheckerNumberMinKind.definition> & DataParserChecker<DataParserCheckerDefinitionNumberMin, number>);
+export declare const checkerNumberMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-number-min", unknown>>;
+type _DataParserCheckerNumberMin = (Kind<typeof checkerNumberMinKind.definition> & DataParserChecker<DataParserCheckerDefinitionNumberMin, number>);
 export interface DataParserCheckerNumberMin extends _DataParserCheckerNumberMin {
 }
 export declare function checkerNumberMin(min: number, definition?: Partial<Omit<DataParserCheckerDefinitionNumberMin, "min">>): DataParserCheckerNumberMin;

package/dist/dataParser/parsers/number/checkers/min.mjs

@@ -2,9 +2,9 @@ import { dataParserCheckerInit } from '../../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../../error.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 
-const dataParserCheckerNumberMinKind = createDataParserKind("checker-number-min");
+const checkerNumberMinKind = createDataParserKind("checker-number-min");
 function checkerNumberMin(min, definition = {}) {
-    return dataParserCheckerInit(dataParserCheckerNumberMinKind, {
+    return dataParserCheckerInit(checkerNumberMinKind, {
         definition: {
             ...definition,
             min,
@@ -12,4 +12,4 @@ function checkerNumberMin(min, definition = {}) {
     }, (value, self) => value >= self.definition.min ? value : SymbolDataParserErrorIssue);
 }
 
-export { checkerNumberMin, dataParserCheckerNumberMinKind };
+export { checkerNumberMin, checkerNumberMinKind };

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

@@ -1,9 +1,13 @@
-import { type NeverCoalescing, type Kind } from "../../../common";
-import { type DataParserDefinition, type DataParser } from "../../base";
+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 DataParserCheckerInt, type DataParserCheckerNumberMin, type DataParserCheckerNumberMax } from "./checkers";
+import { type CheckerRefineImplementation } from "../refine";
+import { type GetPropsWithValueExtends } from "../../../object";
 export * from "./checkers";
-export type DataParserNumberCheckers = (DataParserCheckerInt | DataParserCheckerNumberMin | DataParserCheckerNumberMax);
+export interface DataParserNumberCheckerCustom {
+}
+export type DataParserNumberCheckers = (DataParserNumberCheckerCustom[GetPropsWithValueExtends<DataParserNumberCheckerCustom, DataParserChecker>] | DataParserCheckerInt | DataParserCheckerNumberMin | DataParserCheckerNumberMax | CheckerRefineImplementation<number>);
 export interface DataParserDefinitionNumber extends DataParserDefinition<DataParserNumberCheckers> {
     readonly coerce: boolean;
 }
@@ -13,6 +17,9 @@ export interface DataParserNumber<GenericDefinition extends DataParserDefinition
     addChecker<GenericChecker extends readonly [
         DataParserNumberCheckers,
         ...DataParserNumberCheckers[]
-    ]>(...args: GenericChecker): DataParserNumber<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserNumberCheckers,
+        ...DataParserNumberCheckers[]
+    ], GenericChecker>): DataParserNumber<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function number<const GenericDefinition extends Partial<DataParserDefinitionNumber> = never>(definition?: GenericDefinition): DataParserNumber<MergeDefinition<DataParserDefinitionNumber, NeverCoalescing<GenericDefinition, {}>>>;

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

@@ -1,7 +1,9 @@
-import { type Kind, type IsEqual, type NeverCoalescing, type Memoized } from "../../common";
-import { dataParserKind, type Input, type Output, type DataParser, type DataParserDefinition } from "../base";
-import { type MergeDefinition } from "../types";
+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";
 export type DataParserObjectShape = Readonly<Record<string, DataParser>>;
 export type DataParserObjectShapeOutput<GenericShape extends DataParserObjectShape> = IsEqual<GenericShape, DataParserObjectShape> extends true ? DataParserObjectShape : {
     -readonly [Prop in keyof GenericShape as GenericShape[Prop] extends Kind<typeof dataParserKind.definition> ? Prop : never]: Output<GenericShape[Prop]>;
@@ -9,7 +11,10 @@ export type DataParserObjectShapeOutput<GenericShape extends DataParserObjectSha
 export type DataParserObjectShapeInput<GenericShape extends DataParserObjectShape> = IsEqual<GenericShape, DataParserObjectShape> extends true ? 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 DataParserDefinitionObject extends DataParserDefinition<never> {
+export interface DataParserObjectCheckerCustom<GenericInput extends DataParserObjectShape = DataParserObjectShape> {
+}
+export type DataParserObjectCheckers<GenericInput extends DataParserObjectShape = DataParserObjectShape> = (DataParserObjectCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserObjectCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
+export interface DataParserDefinitionObject extends DataParserDefinition<DataParserObjectCheckers> {
     readonly shape: DataParserObjectShape;
     readonly optimizedShape: Memoized<{
         readonly key: string;
@@ -19,6 +24,13 @@ export interface DataParserDefinitionObject extends DataParserDefinition<never>
 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 [
+        DataParserObjectCheckers<Output<this>>,
+        ...DataParserObjectCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserObjectCheckers<Output<this>>,
+        ...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;

package/dist/dataParser/parsers/optional.cjs

@@ -10,17 +10,18 @@ function optional(inner, definition) {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
             inner,
+            coalescingValue: definition?.coalescingValue,
         },
     }, {
         sync: (data, error, self) => {
             if (data === undefined) {
-                return data;
+                return self.definition.coalescingValue;
             }
             return self.definition.inner.exec(data, error);
         },
         async: async (data, error, self) => {
             if (data === undefined) {
-                return data;
+                return self.definition.coalescingValue;
             }
             return self.definition.inner.asyncExec(data, error);
         },

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

@@ -1,14 +1,27 @@
-import { type NeverCoalescing, type Kind } from "../../common";
-import { type DataParserDefinition, type DataParser, type Output, type Input } from "../base";
-import { type MergeDefinition } from "../../dataParser/types";
-export interface DataParserDefinitionOptional extends DataParserDefinition<never> {
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer, type IsEqual } from "../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input, type DataParserChecker } from "../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
+import { type CheckerRefineImplementation } from "./refine";
+import { type GetPropsWithValueExtends } from "../../object";
+export interface DataParserOptionalCheckerCustom<GenericInput extends unknown = unknown> {
+}
+export type DataParserOptionalCheckers<GenericInput extends unknown = unknown> = (DataParserOptionalCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserOptionalCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
+export interface DataParserDefinitionOptional<GenericCoalescingValue extends unknown = unknown> extends DataParserDefinition<DataParserOptionalCheckers> {
     readonly inner: DataParser;
+    readonly coalescingValue: GenericCoalescingValue;
 }
 export declare const optionalKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/optional", unknown>>;
-type _DataParserOptional<GenericDefinition extends DataParserDefinitionOptional> = (DataParser<GenericDefinition, Output<GenericDefinition["inner"]> | undefined, Input<GenericDefinition["inner"]> | undefined> & Kind<typeof optionalKind.definition>);
+type _DataParserOptional<GenericDefinition extends DataParserDefinitionOptional> = (DataParser<GenericDefinition, IsEqual<GenericDefinition["coalescingValue"], unknown> extends true ? Output<GenericDefinition["inner"]> | undefined : Output<GenericDefinition["inner"]>, Input<GenericDefinition["inner"]> | undefined> & Kind<typeof optionalKind.definition>);
 export interface DataParserOptional<GenericDefinition extends DataParserDefinitionOptional = DataParserDefinitionOptional> extends _DataParserOptional<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserOptionalCheckers<Output<this>>,
+        ...DataParserOptionalCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserOptionalCheckers<Output<this>>,
+        ...DataParserOptionalCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserOptional<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
-export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionOptional, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptional<MergeDefinition<DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
+export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionOptional<Output<GenericDataParser> | undefined>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptional<MergeDefinition<DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
 export {};

package/dist/dataParser/parsers/optional.mjs

@@ -8,17 +8,18 @@ function optional(inner, definition) {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
             inner,
+            coalescingValue: definition?.coalescingValue,
         },
     }, {
         sync: (data, error, self) => {
             if (data === undefined) {
-                return data;
+                return self.definition.coalescingValue;
             }
             return self.definition.inner.exec(data, error);
         },
         async: async (data, error, self) => {
             if (data === undefined) {
-                return data;
+                return self.definition.coalescingValue;
             }
             return self.definition.inner.asyncExec(data, error);
         },

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

@@ -1,13 +1,25 @@
-import { type NeverCoalescing, type Kind } from "../../common";
-import { type DataParserDefinition, type DataParser, type Output, type Input } from "../base";
-import { type MergeDefinition } from "../../dataParser/types";
-export interface DataParserDefinitionPipe extends DataParserDefinition<never> {
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer } from "../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input, type DataParserChecker } from "../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
+import { type CheckerRefineImplementation } from "./refine";
+import { type GetPropsWithValueExtends } from "../../object";
+export interface DataParserPipeCheckerCustom<GenericInput extends unknown = unknown> {
+}
+export type DataParserPipeCheckers<GenericInput extends unknown = unknown> = (DataParserPipeCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserPipeCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
+export interface DataParserDefinitionPipe extends DataParserDefinition<DataParserPipeCheckers> {
     readonly input: DataParser;
     readonly output: DataParser;
 }
 export declare const pipeKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/pipe", unknown>>;
 type _DataParserPipe<GenericDefinition extends DataParserDefinitionPipe> = (DataParser<GenericDefinition, Output<GenericDefinition["output"]>, Input<GenericDefinition["input"]>> & Kind<typeof pipeKind.definition>);
 export interface DataParserPipe<GenericDefinition extends DataParserDefinitionPipe = DataParserDefinitionPipe> extends _DataParserPipe<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserPipeCheckers<Output<this>>,
+        ...DataParserPipeCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserPipeCheckers<Output<this>>,
+        ...DataParserPipeCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserPipe<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function pipe<GenericInput extends DataParser, GenericOutput extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionPipe, "input" | "output">> = never>(input: GenericInput, output: GenericOutput, definition?: GenericDefinition): DataParserPipe<MergeDefinition<DataParserDefinitionPipe, NeverCoalescing<GenericDefinition, {}> & {
     input: GenericInput;

package/dist/dataParser/parsers/record/findRecordRequiredKey.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var pipe = require('../../../common/pipe.cjs');
+var innerPipe = require('../../../common/innerPipe.cjs');
+var when$1 = require('../../../common/when.cjs');
+var isType = require('../../../common/isType.cjs');
+var or = require('../../../common/or.cjs');
+var justReturn = require('../../../common/justReturn.cjs');
+var filter = require('../../../array/filter.cjs');
+var reduce = require('../../../array/reduce.cjs');
+var includes = require('../../../array/includes.cjs');
+var map = require('../../../array/map.cjs');
+var flat = require('../../../array/flat.cjs');
+var flatMap = require('../../../array/flatMap.cjs');
+var notIncludes = require('../../../array/notIncludes.cjs');
+require('../../../common/globalStore.cjs');
+require('../../../common/builder.cjs');
+require('../../../pattern/result.cjs');
+var exhaustive = require('../../../pattern/exhaustive.cjs');
+var otherwise = require('../../../pattern/otherwise.cjs');
+var when = require('../../../pattern/when.cjs');
+var concat = require('../../../string/concat.cjs');
+var index$1 = require('../string/index.cjs');
+var index$2 = require('../number/index.cjs');
+var literal = require('../literal.cjs');
+var union = require('../union.cjs');
+var index = require('../templateLiteral/index.cjs');
+var index$3 = require('../bigint/index.cjs');
+var boolean = require('../boolean.cjs');
+var empty = require('../empty.cjs');
+var nil = require('../nil.cjs');
+
+function findRecordRequiredKeyOnTemplateLiteralPart(templatePart) {
+    return pipe.pipe(templatePart, map.map(innerPipe.innerPipe(when.when((value) => index$1.stringKind.has(value)
+        || index$2.numberKind.has(value)
+        || index$3.bigIntKind.has(value), justReturn.justReturn(null)), when.when(or.or([
+        isType.isType("bigint"),
+        isType.isType("boolean"),
+        isType.isType("null"),
+        isType.isType("number"),
+        isType.isType("string"),
+        isType.isType("undefined"),
+    ]), innerPipe.innerPipe(when$1.when(isType.isType("bigint"), (value) => `${value}n`), String)), when.when(literal.literalKind.has, (value) => findRecordRequiredKey(value)), when.when(index.templateLiteralKind.has, (value) => findRecordRequiredKeyOnTemplateLiteralPart(value.definition.template)), when.when(boolean.booleanKind.has, justReturn.justReturn(["true", "false"])), when.when(empty.emptyKind.has, justReturn.justReturn("undefined")), when.when(nil.nilKind.has, justReturn.justReturn("null")), when.when(union.unionKind.has, (dataParser) => pipe.pipe(dataParser.definition.options, map.map((element) => findRecordRequiredKeyOnTemplateLiteralPart([element])), when.when(notIncludes.notIncludes(null), flat.flat), otherwise.otherwise(justReturn.justReturn(null)))), exhaustive.exhaustive)), reduce.reduce(reduce.reduceFrom([""]), ({ lastValue, element, exit, next }) => pipe.pipe(element, when.when(isType.isType("null"), justReturn.justReturn(exit(null))), when.when(isType.isType("string"), (element) => next(map.map(lastValue, (value) => concat.concat(value, element)))), when.when(isType.isType("array"), (elements) => next(flatMap.flatMap(lastValue, (value) => map.map(elements, (subValue) => concat.concat(value, subValue))))), exhaustive.exhaustive)));
+}
+function findRecordRequiredKey(keyParser) {
+    return pipe.pipe(keyParser, when.when((value) => index$1.stringKind.has(value) || index$2.numberKind.has(value), justReturn.justReturn(null)), when.when(literal.literalKind.has, (dataParser) => pipe.pipe(dataParser.definition.value, map.map(innerPipe.innerPipe(when$1.when(isType.isType("bigint"), (value) => `${value}n`), String)))), when.when(union.unionKind.has, (dataParser) => pipe.pipe(dataParser.definition.options, map.map(findRecordRequiredKey), when.when(includes.includes(null), justReturn.justReturn(null)), otherwise.otherwise(innerPipe.innerPipe(filter.filter(isType.isType("array")), flat.flat)))), when.when(index.templateLiteralKind.has, (dataParser) => findRecordRequiredKeyOnTemplateLiteralPart(dataParser.definition.template)), exhaustive.exhaustive);
+}
+
+exports.findRecordRequiredKey = findRecordRequiredKey;
+exports.findRecordRequiredKeyOnTemplateLiteralPart = findRecordRequiredKeyOnTemplateLiteralPart;

package/dist/dataParser/parsers/record/findRecordRequiredKey.d.ts

@@ -0,0 +1,4 @@
+import { type DataParserRecordKey } from ".";
+import { type TemplateLiteralParts } from "../templateLiteral";
+export declare function findRecordRequiredKeyOnTemplateLiteralPart(templatePart: readonly TemplateLiteralParts[]): string[] | null;
+export declare function findRecordRequiredKey(keyParser: DataParserRecordKey): string[] | null;

package/dist/dataParser/parsers/record/findRecordRequiredKey.mjs

@@ -0,0 +1,47 @@
+import { pipe } from '../../../common/pipe.mjs';
+import { innerPipe } from '../../../common/innerPipe.mjs';
+import { when as when$1 } from '../../../common/when.mjs';
+import { isType } from '../../../common/isType.mjs';
+import { or } from '../../../common/or.mjs';
+import { justReturn } from '../../../common/justReturn.mjs';
+import { filter } from '../../../array/filter.mjs';
+import { reduce, reduceFrom } from '../../../array/reduce.mjs';
+import { includes } from '../../../array/includes.mjs';
+import { map } from '../../../array/map.mjs';
+import { flat } from '../../../array/flat.mjs';
+import { flatMap } from '../../../array/flatMap.mjs';
+import { notIncludes } from '../../../array/notIncludes.mjs';
+import '../../../common/globalStore.mjs';
+import '../../../common/builder.mjs';
+import '../../../pattern/result.mjs';
+import { exhaustive } from '../../../pattern/exhaustive.mjs';
+import { otherwise } from '../../../pattern/otherwise.mjs';
+import { when } from '../../../pattern/when.mjs';
+import { concat } from '../../../string/concat.mjs';
+import { stringKind } from '../string/index.mjs';
+import { numberKind } from '../number/index.mjs';
+import { literalKind } from '../literal.mjs';
+import { unionKind } from '../union.mjs';
+import { templateLiteralKind } from '../templateLiteral/index.mjs';
+import { bigIntKind } from '../bigint/index.mjs';
+import { booleanKind } from '../boolean.mjs';
+import { emptyKind } from '../empty.mjs';
+import { nilKind } from '../nil.mjs';
+
+function findRecordRequiredKeyOnTemplateLiteralPart(templatePart) {
+    return pipe(templatePart, map(innerPipe(when((value) => stringKind.has(value)
+        || numberKind.has(value)
+        || bigIntKind.has(value), justReturn(null)), when(or([
+        isType("bigint"),
+        isType("boolean"),
+        isType("null"),
+        isType("number"),
+        isType("string"),
+        isType("undefined"),
+    ]), innerPipe(when$1(isType("bigint"), (value) => `${value}n`), String)), when(literalKind.has, (value) => findRecordRequiredKey(value)), when(templateLiteralKind.has, (value) => findRecordRequiredKeyOnTemplateLiteralPart(value.definition.template)), when(booleanKind.has, justReturn(["true", "false"])), when(emptyKind.has, justReturn("undefined")), when(nilKind.has, justReturn("null")), when(unionKind.has, (dataParser) => pipe(dataParser.definition.options, map((element) => findRecordRequiredKeyOnTemplateLiteralPart([element])), when(notIncludes(null), flat), otherwise(justReturn(null)))), exhaustive)), reduce(reduceFrom([""]), ({ lastValue, element, exit, next }) => pipe(element, when(isType("null"), justReturn(exit(null))), when(isType("string"), (element) => next(map(lastValue, (value) => concat(value, element)))), when(isType("array"), (elements) => next(flatMap(lastValue, (value) => map(elements, (subValue) => concat(value, subValue))))), exhaustive)));
+}
+function findRecordRequiredKey(keyParser) {
+    return pipe(keyParser, when((value) => stringKind.has(value) || numberKind.has(value), justReturn(null)), when(literalKind.has, (dataParser) => pipe(dataParser.definition.value, map(innerPipe(when$1(isType("bigint"), (value) => `${value}n`), String)))), when(unionKind.has, (dataParser) => pipe(dataParser.definition.options, map(findRecordRequiredKey), when(includes(null), justReturn(null)), otherwise(innerPipe(filter(isType("array")), flat)))), when(templateLiteralKind.has, (dataParser) => findRecordRequiredKeyOnTemplateLiteralPart(dataParser.definition.template)), exhaustive);
+}
+
+export { findRecordRequiredKey, findRecordRequiredKeyOnTemplateLiteralPart };

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

@@ -1,8 +1,9 @@
 'use strict';
 
-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 findRecordRequiredKey = require('./findRecordRequiredKey.cjs');
 
 const recordKind = kind.createDataParserKind("record");
 function record(key, value, definition) {
@@ -12,6 +13,7 @@ function record(key, value, definition) {
             checkers: definition?.checkers ?? [],
             key,
             value,
+            requireKey: findRecordRequiredKey.findRecordRequiredKey(key),
         },
     }, {
         sync: (data, error$1, self) => {
@@ -43,6 +45,13 @@ function record(key, value, definition) {
                 }
             }
             error.popErrorPath(error$1);
+            if (output === base.SymbolDataParserError) {
+                return output;
+            }
+            if (self.definition.requireKey
+                && self.definition.requireKey.length !== Object.keys(output).length) {
+                return error.SymbolDataParserErrorIssue;
+            }
             return output;
         },
         async: async (data, error$1, self) => {
@@ -74,10 +83,19 @@ function record(key, value, definition) {
                 }
             }
             error.popErrorPath(error$1);
+            if (output === base.SymbolDataParserError) {
+                return output;
+            }
+            if (self.definition.requireKey
+                && self.definition.requireKey.length !== Object.keys(output).length) {
+                return error.SymbolDataParserErrorIssue;
+            }
             return output;
         },
     });
 }
 
+exports.findRecordRequiredKey = findRecordRequiredKey.findRecordRequiredKey;
+exports.findRecordRequiredKeyOnTemplateLiteralPart = findRecordRequiredKey.findRecordRequiredKeyOnTemplateLiteralPart;
 exports.record = record;
 exports.recordKind = recordKind;

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

@@ -0,0 +1,42 @@
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer, type Adaptor } from "../../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input, type DataParserChecker } from "../../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../../dataParser/types";
+import { type DataParserString } from "../string";
+import { type DataParserTemplateLiteral } from "../templateLiteral";
+import { type DataParserLiteral } from "../literal";
+import { type DataParserDefinitionNumber, type DataParserNumber } from "../number";
+import { type DataParserDefinitionUnion, type DataParserUnion } from "../union";
+import { type CheckerRefineImplementation } from "../refine";
+import { type TemplateLiteralContainLargeType } from "../../../string";
+import { type GetPropsWithValueExtends } from "../../../object";
+export * from "./findRecordRequiredKey";
+export type DataParserRecordKey = (DataParserString | DataParserTemplateLiteral | DataParserLiteral | DataParserNumber<DataParserDefinitionNumber & {
+    coerce: true;
+}> | DataParserUnion<DataParserDefinitionUnion & {
+    options: DataParserRecordKey[];
+}>);
+export interface DataParserRecordCheckerCustom<GenericInput extends Record<string, unknown> = Record<string, unknown>> {
+}
+export type DataParserRecordCheckers<GenericInput extends Record<string, unknown> = Record<string, unknown>> = (DataParserRecordCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserRecordCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
+export interface DataParserDefinitionRecord extends DataParserDefinition<DataParserRecordCheckers> {
+    readonly key: DataParserRecordKey;
+    readonly value: DataParser;
+    readonly requireKey: string[] | null;
+}
+export declare const recordKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/record", unknown>>;
+export type DataParserRecordShapeOutput<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParser> = Extract<Record<Output<GenericDataParserKey> extends infer InferredKey extends string | number ? `${InferredKey}` : never, Output<GenericDataParserValue> extends infer InferredValue ? InferredValue : never>, any>;
+export type DataParserRecordShapeInput<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParser> = Extract<Record<Input<GenericDataParserKey> extends infer InferredKey extends string | number ? `${InferredKey}` : never, Input<GenericDataParserValue> extends infer InferredValue ? InferredValue : never>, any>;
+type _DataParserRecord<GenericDefinition extends DataParserDefinitionRecord> = (DataParser<GenericDefinition, DataParserRecordShapeOutput<GenericDefinition["key"], GenericDefinition["value"]> extends infer InferredOutput extends Record<string, unknown> ? TemplateLiteralContainLargeType<Adaptor<keyof InferredOutput, string>> extends true ? Partial<InferredOutput> : InferredOutput : never, DataParserRecordShapeInput<GenericDefinition["key"], GenericDefinition["value"]> extends infer InferredInput extends Record<string, unknown> ? TemplateLiteralContainLargeType<Adaptor<keyof InferredInput, string>> extends true ? Partial<InferredInput> : InferredInput : never> & Kind<typeof recordKind.definition>);
+export interface DataParserRecord<GenericDefinition extends DataParserDefinitionRecord = DataParserDefinitionRecord> extends _DataParserRecord<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserRecordCheckers<Output<this>>,
+        ...DataParserRecordCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserRecordCheckers<Output<this>>,
+        ...DataParserRecordCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserRecord<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+}
+export declare function record<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParser, const GenericDefinition extends Partial<DataParserDefinitionRecord> = never>(key: GenericDataParserKey, value: GenericDataParserValue, definition?: GenericDefinition): DataParserRecord<MergeDefinition<DataParserDefinitionRecord, NeverCoalescing<GenericDefinition, {}> & {
+    key: GenericDataParserKey;
+    value: GenericDataParserValue;
+}>>;

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

@@ -1,6 +1,8 @@
-import { dataParserInit, SymbolDataParserError } from '../base.mjs';
-import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../error.mjs';
-import { createDataParserKind } from '../kind.mjs';
+import { dataParserInit, SymbolDataParserError } from '../../base.mjs';
+import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../../error.mjs';
+import { createDataParserKind } from '../../kind.mjs';
+import { findRecordRequiredKey } from './findRecordRequiredKey.mjs';
+export { findRecordRequiredKeyOnTemplateLiteralPart } from './findRecordRequiredKey.mjs';
 
 const recordKind = createDataParserKind("record");
 function record(key, value, definition) {
@@ -10,6 +12,7 @@ function record(key, value, definition) {
             checkers: definition?.checkers ?? [],
             key,
             value,
+            requireKey: findRecordRequiredKey(key),
         },
     }, {
         sync: (data, error, self) => {
@@ -41,6 +44,13 @@ function record(key, value, definition) {
                 }
             }
             popErrorPath(error);
+            if (output === SymbolDataParserError) {
+                return output;
+            }
+            if (self.definition.requireKey
+                && self.definition.requireKey.length !== Object.keys(output).length) {
+                return SymbolDataParserErrorIssue;
+            }
             return output;
         },
         async: async (data, error, self) => {
@@ -72,9 +82,16 @@ function record(key, value, definition) {
                 }
             }
             popErrorPath(error);
+            if (output === SymbolDataParserError) {
+                return output;
+            }
+            if (self.definition.requireKey
+                && self.definition.requireKey.length !== Object.keys(output).length) {
+                return SymbolDataParserErrorIssue;
+            }
             return output;
         },
     });
 }
 
-export { record, recordKind };
+export { findRecordRequiredKey, record, recordKind };

package/dist/dataParser/parsers/recover.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var base = require('../base.cjs');
+var kind = require('../kind.cjs');
+
+const recoverKind = kind.createDataParserKind("recover");
+function recover(inner, recoveredValue, definition) {
+    return base.dataParserInit(recoverKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            inner,
+            recoveredValue,
+        },
+    }, {
+        sync: (data, error, self) => {
+            const result = self.definition.inner.exec(data, error);
+            return result === base.SymbolDataParserError
+                ? self.definition.recoveredValue
+                : result;
+        },
+        async: async (data, error, self) => {
+            const result = await self.definition.inner.asyncExec(data, error);
+            return result === base.SymbolDataParserError
+                ? self.definition.recoveredValue
+                : result;
+        },
+    });
+}
+
+exports.recover = recover;
+exports.recoverKind = recoverKind;

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

@@ -0,0 +1,28 @@
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer } from "../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input, type DataParserChecker } from "../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
+import { type CheckerRefineImplementation } from "./refine";
+import { type GetPropsWithValueExtends } from "../../object";
+export interface DataParserRecoverCheckerCustom<GenericInput extends unknown = unknown> {
+}
+export type DataParserRecoverCheckers<GenericInput extends unknown = unknown> = (DataParserRecoverCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserRecoverCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
+export interface DataParserDefinitionRecover extends DataParserDefinition<DataParserRecoverCheckers> {
+    readonly inner: DataParser;
+    readonly recoveredValue: unknown;
+}
+export declare const recoverKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/recover", unknown>>;
+type _DataParserRecover<GenericDefinition extends DataParserDefinitionRecover> = (DataParser<GenericDefinition, GenericDefinition["recoveredValue"], Input<GenericDefinition["inner"]>> & Kind<typeof recoverKind.definition>);
+export interface DataParserRecover<GenericDefinition extends DataParserDefinitionRecover = DataParserDefinitionRecover> extends _DataParserRecover<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserRecoverCheckers<Output<this>>,
+        ...DataParserRecoverCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserRecoverCheckers<Output<this>>,
+        ...DataParserRecoverCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserRecover<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+}
+export declare function recover<GenericDataParser extends DataParser, GenericRecoveredValue extends unknown, const GenericDefinition extends Partial<Omit<DataParserDefinitionRecover, "inner" | "recoveredValue">> = never>(inner: GenericDataParser, recoveredValue: GenericRecoveredValue, definition?: GenericDefinition): DataParserRecover<MergeDefinition<DataParserDefinitionRecover, NeverCoalescing<GenericDefinition, {}> & {
+    inner: GenericDataParser;
+    recoveredValue: GenericRecoveredValue;
+}>>;
+export {};

package/dist/dataParser/parsers/recover.mjs

@@ -0,0 +1,29 @@
+import { dataParserInit, SymbolDataParserError } from '../base.mjs';
+import { createDataParserKind } from '../kind.mjs';
+
+const recoverKind = createDataParserKind("recover");
+function recover(inner, recoveredValue, definition) {
+    return dataParserInit(recoverKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            inner,
+            recoveredValue,
+        },
+    }, {
+        sync: (data, error, self) => {
+            const result = self.definition.inner.exec(data, error);
+            return result === SymbolDataParserError
+                ? self.definition.recoveredValue
+                : result;
+        },
+        async: async (data, error, self) => {
+            const result = await self.definition.inner.asyncExec(data, error);
+            return result === SymbolDataParserError
+                ? self.definition.recoveredValue
+                : result;
+        },
+    });
+}
+
+export { recover, recoverKind };

package/dist/dataParser/parsers/refine.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var base = require('../base.cjs');
+var error = require('../error.cjs');
+var kind = require('../kind.cjs');
+
+const dataParserCheckerRefineKind = kind.createDataParserKind("checker-string-max");
+function checkerRefine(theFunction, definition) {
+    return base.dataParserCheckerInit(dataParserCheckerRefineKind, {
+        definition: {
+            ...definition,
+            theFunction,
+        },
+    }, (value, self) => self.definition.theFunction(value) ? value : error.SymbolDataParserErrorIssue);
+}
+
+exports.checkerRefine = checkerRefine;
+exports.dataParserCheckerRefineKind = dataParserCheckerRefineKind;

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

@@ -0,0 +1,17 @@
+import { type NeverCoalescing, type Kind } from "../../common";
+import { type DataParserCheckerDefinition, type DataParserChecker } from "../../dataParser/base";
+import { type AssignObjects } from "../../object";
+export interface DataParserCheckerDefinitionRefine extends DataParserCheckerDefinition {
+    theFunction(input: unknown): boolean;
+}
+export declare const dataParserCheckerRefineKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-max", unknown>>;
+type _DataParserCheckerRefine<GenericDefinition extends DataParserCheckerDefinitionRefine> = (Kind<typeof dataParserCheckerRefineKind.definition> & DataParserChecker<GenericDefinition, string>);
+export interface DataParserCheckerRefine<GenericDefinition extends DataParserCheckerDefinitionRefine = DataParserCheckerDefinitionRefine> extends _DataParserCheckerRefine<GenericDefinition> {
+}
+export declare function checkerRefine<GenericInput extends unknown, const GenericDefinition extends Partial<Omit<DataParserCheckerDefinitionRefine, "theFunction">> = never>(theFunction: (input: GenericInput) => boolean, definition?: GenericDefinition): DataParserCheckerRefine<AssignObjects<NeverCoalescing<GenericDefinition, {}>, {
+    theFunction(input: GenericInput): boolean;
+}>>;
+export type CheckerRefineImplementation<GenericInput extends unknown> = DataParserCheckerRefine<AssignObjects<DataParserCheckerDefinitionRefine, {
+    theFunction(input: GenericInput): boolean;
+}>>;
+export {};