@duplojs/utils 1.1.12 → 1.1.14

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 {};

package/dist/dataParser/parsers/refine.mjs

@@ -0,0 +1,15 @@
+import { dataParserCheckerInit } from '../base.mjs';
+import { SymbolDataParserErrorIssue } from '../error.mjs';
+import { createDataParserKind } from '../kind.mjs';
+
+const dataParserCheckerRefineKind = createDataParserKind("checker-string-max");
+function checkerRefine(theFunction, definition) {
+    return dataParserCheckerInit(dataParserCheckerRefineKind, {
+        definition: {
+            ...definition,
+            theFunction,
+        },
+    }, (value, self) => self.definition.theFunction(value) ? value : SymbolDataParserErrorIssue);
+}
+
+export { checkerRefine, dataParserCheckerRefineKind };

package/dist/dataParser/parsers/string/checkers/email.cjs

@@ -5,10 +5,10 @@ var error = require('../../../error.cjs');
 var index = require('../index.cjs');
 var kind = require('../../../kind.cjs');
 
-const dataParserCheckerEmailKind = kind.createDataParserKind("checker-string-email");
+const checkerEmailKind = kind.createDataParserKind("checker-string-email");
 const emailPattern = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9-]*\.)+[A-Za-z]{2,}$/;
 function checkerEmail(definition = {}) {
-    return base.dataParserCheckerInit(dataParserCheckerEmailKind, {
+    return base.dataParserCheckerInit(checkerEmailKind, {
         definition: {
             ...definition,
             pattern: emailPattern,
@@ -27,5 +27,5 @@ function email(definition) {
 }
 
 exports.checkerEmail = checkerEmail;
-exports.dataParserCheckerEmailKind = dataParserCheckerEmailKind;
+exports.checkerEmailKind = checkerEmailKind;
 exports.email = email;

package/dist/dataParser/parsers/string/checkers/email.d.ts

@@ -4,8 +4,8 @@ export interface DataParserCheckerDefinitionEmail extends DataParserCheckerDefin
     normalize?: boolean;
     pattern: RegExp;
 }
-export declare const dataParserCheckerEmailKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-email", unknown>>;
-type _DataParserCheckerEmail = (Kind<typeof dataParserCheckerEmailKind.definition> & DataParserChecker<DataParserCheckerDefinitionEmail, string>);
+export declare const checkerEmailKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-email", unknown>>;
+type _DataParserCheckerEmail = (Kind<typeof checkerEmailKind.definition> & DataParserChecker<DataParserCheckerDefinitionEmail, string>);
 export interface DataParserCheckerEmail extends _DataParserCheckerEmail {
 }
 export declare function checkerEmail(definition?: Partial<DataParserCheckerDefinitionEmail>): DataParserCheckerEmail;

package/dist/dataParser/parsers/string/checkers/email.mjs

@@ -3,10 +3,10 @@ import { SymbolDataParserErrorIssue } from '../../../error.mjs';
 import { string } from '../index.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 
-const dataParserCheckerEmailKind = createDataParserKind("checker-string-email");
+const checkerEmailKind = createDataParserKind("checker-string-email");
 const emailPattern = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9-]*\.)+[A-Za-z]{2,}$/;
 function checkerEmail(definition = {}) {
-    return dataParserCheckerInit(dataParserCheckerEmailKind, {
+    return dataParserCheckerInit(checkerEmailKind, {
         definition: {
             ...definition,
             pattern: emailPattern,
@@ -24,4 +24,4 @@ function email(definition) {
     });
 }
 
-export { checkerEmail, dataParserCheckerEmailKind, email };
+export { checkerEmail, checkerEmailKind, email };

package/dist/dataParser/parsers/string/checkers/max.cjs

@@ -4,9 +4,9 @@ var base = require('../../../base.cjs');
 var error = require('../../../error.cjs');
 var kind = require('../../../kind.cjs');
 
-const dataParserCheckerStringMaxKind = kind.createDataParserKind("checker-string-max");
+const checkerStringMaxKind = kind.createDataParserKind("checker-string-max");
 function checkerStringMax(max, definition = {}) {
-    return base.dataParserCheckerInit(dataParserCheckerStringMaxKind, {
+    return base.dataParserCheckerInit(checkerStringMaxKind, {
         definition: {
             ...definition,
             max,
@@ -15,4 +15,4 @@ function checkerStringMax(max, definition = {}) {
 }
 
 exports.checkerStringMax = checkerStringMax;
-exports.dataParserCheckerStringMaxKind = dataParserCheckerStringMaxKind;
+exports.checkerStringMaxKind = checkerStringMaxKind;

package/dist/dataParser/parsers/string/checkers/max.d.ts

@@ -3,8 +3,8 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionStringMax extends DataParserCheckerDefinition {
     max: number;
 }
-export declare const dataParserCheckerStringMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-max", unknown>>;
-type _DataParserCheckerStringMax = (Kind<typeof dataParserCheckerStringMaxKind.definition> & DataParserChecker<DataParserCheckerDefinitionStringMax, string>);
+export declare const checkerStringMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-max", unknown>>;
+type _DataParserCheckerStringMax = (Kind<typeof checkerStringMaxKind.definition> & DataParserChecker<DataParserCheckerDefinitionStringMax, string>);
 export interface DataParserCheckerStringMax extends _DataParserCheckerStringMax {
 }
 export declare function checkerStringMax(max: number, definition?: Partial<Omit<DataParserCheckerDefinitionStringMax, "max">>): DataParserCheckerStringMax;

package/dist/dataParser/parsers/string/checkers/max.mjs

@@ -2,9 +2,9 @@ import { dataParserCheckerInit } from '../../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../../error.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 
-const dataParserCheckerStringMaxKind = createDataParserKind("checker-string-max");
+const checkerStringMaxKind = createDataParserKind("checker-string-max");
 function checkerStringMax(max, definition = {}) {
-    return dataParserCheckerInit(dataParserCheckerStringMaxKind, {
+    return dataParserCheckerInit(checkerStringMaxKind, {
         definition: {
             ...definition,
             max,
@@ -12,4 +12,4 @@ function checkerStringMax(max, definition = {}) {
     }, (value, self) => value.length <= self.definition.max ? value : SymbolDataParserErrorIssue);
 }
 
-export { checkerStringMax, dataParserCheckerStringMaxKind };
+export { checkerStringMax, checkerStringMaxKind };

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

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

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

@@ -3,8 +3,8 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionStringMin extends DataParserCheckerDefinition {
     min: number;
 }
-export declare const dataParserCheckerStringMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-min", unknown>>;
-type _DataParserCheckerStringMin = (Kind<typeof dataParserCheckerStringMinKind.definition> & DataParserChecker<DataParserCheckerDefinitionStringMin, string>);
+export declare const checkerStringMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-min", unknown>>;
+type _DataParserCheckerStringMin = (Kind<typeof checkerStringMinKind.definition> & DataParserChecker<DataParserCheckerDefinitionStringMin, string>);
 export interface DataParserCheckerStringMin extends _DataParserCheckerStringMin {
 }
 export declare function checkerStringMin(min: number, definition?: Partial<Omit<DataParserCheckerDefinitionStringMin, "min">>): DataParserCheckerStringMin;

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

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

package/dist/dataParser/parsers/string/checkers/regex.cjs

@@ -4,9 +4,9 @@ var base = require('../../../base.cjs');
 var error = require('../../../error.cjs');
 var kind = require('../../../kind.cjs');
 
-const dataParserCheckerStringRegexKind = kind.createDataParserKind("checker-string-regex");
+const checkerStringRegexKind = kind.createDataParserKind("checker-string-regex");
 function checkerStringRegex(regex, definition = {}) {
-    return base.dataParserCheckerInit(dataParserCheckerStringRegexKind, {
+    return base.dataParserCheckerInit(checkerStringRegexKind, {
         definition: {
             ...definition,
             regex,
@@ -17,4 +17,4 @@ function checkerStringRegex(regex, definition = {}) {
 }
 
 exports.checkerStringRegex = checkerStringRegex;
-exports.dataParserCheckerStringRegexKind = dataParserCheckerStringRegexKind;
+exports.checkerStringRegexKind = checkerStringRegexKind;

package/dist/dataParser/parsers/string/checkers/regex.d.ts

@@ -3,8 +3,8 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionStringRegex extends DataParserCheckerDefinition {
     regex: RegExp;
 }
-export declare const dataParserCheckerStringRegexKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-regex", unknown>>;
-type _DataParserCheckerStringRegex = (Kind<typeof dataParserCheckerStringRegexKind.definition> & DataParserChecker<DataParserCheckerDefinitionStringRegex, string>);
+export declare const checkerStringRegexKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-regex", unknown>>;
+type _DataParserCheckerStringRegex = (Kind<typeof checkerStringRegexKind.definition> & DataParserChecker<DataParserCheckerDefinitionStringRegex, string>);
 export interface DataParserCheckerStringRegex extends _DataParserCheckerStringRegex {
 }
 export declare function checkerStringRegex(regex: RegExp, definition?: Partial<Omit<DataParserCheckerDefinitionStringRegex, "regex">>): DataParserCheckerStringRegex;

package/dist/dataParser/parsers/string/checkers/regex.mjs

@@ -2,9 +2,9 @@ import { dataParserCheckerInit } from '../../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../../error.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 
-const dataParserCheckerStringRegexKind = createDataParserKind("checker-string-regex");
+const checkerStringRegexKind = createDataParserKind("checker-string-regex");
 function checkerStringRegex(regex, definition = {}) {
-    return dataParserCheckerInit(dataParserCheckerStringRegexKind, {
+    return dataParserCheckerInit(checkerStringRegexKind, {
         definition: {
             ...definition,
             regex,
@@ -14,4 +14,4 @@ function checkerStringRegex(regex, definition = {}) {
         : SymbolDataParserErrorIssue);
 }
 
-export { checkerStringRegex, dataParserCheckerStringRegexKind };
+export { checkerStringRegex, checkerStringRegexKind };

package/dist/dataParser/parsers/string/checkers/url.cjs

@@ -5,10 +5,10 @@ var error = require('../../../error.cjs');
 var index = require('../index.cjs');
 var kind = require('../../../kind.cjs');
 
-const dataParserCheckerUrlKind = kind.createDataParserKind("checker-string-url");
+const checkerUrlKind = kind.createDataParserKind("checker-string-url");
 const regexRemoveDote = /:$/;
 function checkerUrl(definition = {}) {
-    return base.dataParserCheckerInit(dataParserCheckerUrlKind, {
+    return base.dataParserCheckerInit(checkerUrlKind, {
         definition: definition,
     }, (input, self) => {
         try {
@@ -44,5 +44,5 @@ function url(definition) {
 }
 
 exports.checkerUrl = checkerUrl;
-exports.dataParserCheckerUrlKind = dataParserCheckerUrlKind;
+exports.checkerUrlKind = checkerUrlKind;
 exports.url = url;

package/dist/dataParser/parsers/string/checkers/url.d.ts

@@ -5,8 +5,8 @@ export interface DataParserCheckerDefinitionUrl extends DataParserCheckerDefinit
     protocol?: RegExp;
     normalize?: boolean;
 }
-export declare const dataParserCheckerUrlKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-url", unknown>>;
-type _DataParserCheckerUrl = (Kind<typeof dataParserCheckerUrlKind.definition> & DataParserChecker<DataParserCheckerDefinitionUrl, string>);
+export declare const checkerUrlKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-url", unknown>>;
+type _DataParserCheckerUrl = (Kind<typeof checkerUrlKind.definition> & DataParserChecker<DataParserCheckerDefinitionUrl, string>);
 export interface DataParserCheckerUrl extends _DataParserCheckerUrl {
 }
 export declare function checkerUrl(definition?: Partial<DataParserCheckerDefinitionUrl>): DataParserCheckerUrl;

package/dist/dataParser/parsers/string/checkers/url.mjs

@@ -3,10 +3,10 @@ import { SymbolDataParserErrorIssue } from '../../../error.mjs';
 import { string } from '../index.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 
-const dataParserCheckerUrlKind = createDataParserKind("checker-string-url");
+const checkerUrlKind = createDataParserKind("checker-string-url");
 const regexRemoveDote = /:$/;
 function checkerUrl(definition = {}) {
-    return dataParserCheckerInit(dataParserCheckerUrlKind, {
+    return dataParserCheckerInit(checkerUrlKind, {
         definition: definition,
     }, (input, self) => {
         try {
@@ -41,4 +41,4 @@ function url(definition) {
     });
 }
 
-export { checkerUrl, dataParserCheckerUrlKind, url };
+export { checkerUrl, checkerUrlKind, url };

package/dist/dataParser/parsers/string/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 DataParserCheckerUrl, type DataParserCheckerEmail, type DataParserCheckerStringMin, type DataParserCheckerStringMax, type DataParserCheckerStringRegex } from "./checkers";
+import { type CheckerRefineImplementation } from "../refine";
+import { type GetPropsWithValueExtends } from "../../../object";
 export * from "./checkers";
-export type DataParserStringCheckers = (DataParserCheckerUrl | DataParserCheckerEmail | DataParserCheckerStringMin | DataParserCheckerStringMax | DataParserCheckerStringRegex);
+export interface DataParserStringCheckerCustom {
+}
+export type DataParserStringCheckers = (DataParserStringCheckerCustom[GetPropsWithValueExtends<DataParserStringCheckerCustom, DataParserChecker>] | DataParserCheckerUrl | DataParserCheckerEmail | DataParserCheckerStringMin | DataParserCheckerStringMax | DataParserCheckerStringRegex | CheckerRefineImplementation<string>);
 export interface DataParserDefinitionString extends DataParserDefinition<DataParserStringCheckers> {
     readonly coerce: boolean;
 }
@@ -13,6 +17,9 @@ export interface DataParserString<GenericDefinition extends DataParserDefinition
     addChecker<GenericChecker extends readonly [
         DataParserStringCheckers,
         ...DataParserStringCheckers[]
-    ]>(...args: GenericChecker): DataParserString<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserStringCheckers,
+        ...DataParserStringCheckers[]
+    ], GenericChecker>): DataParserString<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function string<const GenericDefinition extends Partial<DataParserDefinitionString> = never>(definition?: GenericDefinition): DataParserString<MergeDefinition<DataParserDefinitionString, NeverCoalescing<GenericDefinition, {}>>>;

package/dist/dataParser/parsers/templateLiteral/createTemplateLiteralPattern.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+var escapeRegExp = require('../../../common/escapeRegExp.cjs');
+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 find = require('../../../array/find.cjs');
+var to = require('../../../object/to.cjs');
+var map = require('../../../array/map.cjs');
+var join = require('../../../array/join.cjs');
+require('../../../common/globalStore.cjs');
+require('../../../common/builder.cjs');
+var index = require('./index.cjs');
+require('../../../pattern/result.cjs');
+var exhaustive = require('../../../pattern/exhaustive.cjs');
+var when = require('../../../pattern/when.cjs');
+var replace = require('../../../string/replace.cjs');
+var index$3 = require('../number/index.cjs');
+var index$2 = require('../bigint/index.cjs');
+var boolean = require('../boolean.cjs');
+var nil = require('../nil.cjs');
+var empty = require('../empty.cjs');
+var literal = require('../literal.cjs');
+var index$1 = require('../string/index.cjs');
+var union = require('../union.cjs');
+var regex = require('../string/checkers/regex.cjs');
+var max = require('../string/checkers/max.cjs');
+var min = require('../string/checkers/min.cjs');
+var email = require('../string/checkers/email.cjs');
+var int = require('../number/checkers/int.cjs');
+
+function createTemplateLiteralPattern(templatePart) {
+    return pipe.pipe(templatePart, map.map(innerPipe.innerPipe(when.when(or.or([
+        isType.isType("string"),
+        isType.isType("boolean"),
+        isType.isType("bigint"),
+        isType.isType("null"),
+        isType.isType("undefined"),
+        isType.isType("number"),
+    ]), innerPipe.innerPipe(when$1.when(isType.isType("bigint"), (value) => `${value}n`), String, escapeRegExp.escapeRegExp, (value) => `(?:${value})`)), when.when(index$3.numberKind.has, (dataParser) => pipe.pipe(dataParser.definition.checkers, to.to({
+        int: innerPipe.innerPipe(find.find(int.checkerIntKind.has), when$1.when(int.checkerIntKind.has, justReturn.justReturn(true))),
+    }), ({ int }) => {
+        if (int) {
+            return "(?:[0-9]+)";
+        }
+        return "(?:[0-9]+(\\.[0-9]+)?)";
+    })), when.when(index$2.bigIntKind.has, () => "(?:[0-9]+n)"), when.when(boolean.booleanKind.has, () => "(?:true|false)"), when.when(nil.nilKind.has, () => "(?:null)"), when.when(empty.emptyKind.has, () => "(?:undefined)"), when.when(literal.literalKind.has, (dataParser) => pipe.pipe(dataParser.definition.value, map.map((element) => createTemplateLiteralPattern([element])), join.join("|"), (pattern) => `(?:${pattern})`)), when.when(index$1.stringKind.has, (dataParser) => pipe.pipe(dataParser.definition.checkers, to.to({
+        email: innerPipe.innerPipe(find.find(email.checkerEmailKind.has), when$1.when(email.checkerEmailKind.has, (checker) => pipe.pipe(checker.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, "")))),
+        min: innerPipe.innerPipe(find.find(min.checkerStringMinKind.has), when$1.when(min.checkerStringMinKind.has, (checker) => checker.definition.min)),
+        max: innerPipe.innerPipe(find.find(max.checkerStringMaxKind.has), when$1.when(max.checkerStringMaxKind.has, (checker) => checker.definition.max)),
+        regex: innerPipe.innerPipe(find.find(regex.checkerStringRegexKind.has), when$1.when(regex.checkerStringRegexKind.has, (checker) => pipe.pipe(checker.definition.regex.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, "")))),
+    }), ({ email, regex, max, min }) => {
+        if (email) {
+            return email;
+        }
+        else if (regex) {
+            return regex;
+        }
+        else if (max !== undefined && min !== undefined) {
+            return `(?:[^]{${min},${max}})`;
+        }
+        else if (max !== undefined) {
+            return `(?:[^]{0,${max}})`;
+        }
+        else if (min !== undefined) {
+            return `(?:[^]{${min},})`;
+        }
+        return "(?:[^]*)";
+    })), innerPipe.innerPipe(when.when(index.templateLiteralKind.has, (dataParser) => pipe.pipe(dataParser.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, ""), (pattern) => `(?:${pattern})`)), when.when(union.unionKind.has, (dataParser) => pipe.pipe(dataParser.definition.options, map.map((option) => createTemplateLiteralPattern([option])), join.join("|"), (pattern) => `(?:${pattern})`)), exhaustive.exhaustive))), join.join(""));
+}
+
+exports.createTemplateLiteralPattern = createTemplateLiteralPattern;

package/dist/dataParser/parsers/templateLiteral/createTemplateLiteralPattern.d.ts

@@ -0,0 +1,2 @@
+import { type TemplateLiteralParts } from ".";
+export declare function createTemplateLiteralPattern(templatePart: readonly TemplateLiteralParts[]): string;