@duplojs/utils 1.0.6 → 1.1.7

package/dist/dataParser/parsers/record.mjs

@@ -0,0 +1,80 @@
+import { createKind } from '../../common/kind.mjs';
+import { dataParserInit, SymbolDataParserError } from '../base.mjs';
+import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../error.mjs';
+
+const dataParserRecordKind = createKind("data-parser-record");
+function record(key, value, definition) {
+    return dataParserInit(dataParserRecordKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            key,
+            value,
+        },
+    }, {
+        sync: (data, error, self) => {
+            if (!data
+                || typeof data !== "object"
+                || data instanceof Array) {
+                return SymbolDataParserErrorIssue;
+            }
+            let output = {};
+            const currentIndexPath = error.currentPath.length;
+            for (const key in data) {
+                setErrorPath(error, key, currentIndexPath);
+                const resultKey = self
+                    .definition
+                    .key
+                    .exec(key, error);
+                if (resultKey === SymbolDataParserError) {
+                    output = SymbolDataParserError;
+                }
+                const resultValue = self
+                    .definition
+                    .value
+                    .exec(data[key], error);
+                if (resultValue === SymbolDataParserError) {
+                    output = SymbolDataParserError;
+                }
+                if (output !== SymbolDataParserError) {
+                    output[resultKey] = resultValue;
+                }
+            }
+            popErrorPath(error);
+            return output;
+        },
+        async: async (data, error, self) => {
+            if (!data
+                || typeof data !== "object"
+                || data instanceof Array) {
+                return SymbolDataParserErrorIssue;
+            }
+            let output = {};
+            const currentIndexPath = error.currentPath.length;
+            for (const key in data) {
+                setErrorPath(error, key, currentIndexPath);
+                const resultKey = await self
+                    .definition
+                    .key
+                    .asyncExec(key, error);
+                if (resultKey === SymbolDataParserError) {
+                    output = SymbolDataParserError;
+                }
+                const resultValue = await self
+                    .definition
+                    .value
+                    .asyncExec(data[key], error);
+                if (resultValue === SymbolDataParserError) {
+                    output = SymbolDataParserError;
+                }
+                if (output !== SymbolDataParserError) {
+                    output[resultKey] = resultValue;
+                }
+            }
+            popErrorPath(error);
+            return output;
+        },
+    });
+}
+
+export { dataParserRecordKind, record };

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

@@ -0,0 +1,31 @@
+'use strict';
+
+var kind = require('../../../../common/kind.cjs');
+var base = require('../../../base.cjs');
+var error = require('../../../error.cjs');
+var index = require('../index.cjs');
+
+const dataParserCheckerEmailKind = kind.createKind("data-parser-checker-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, {
+        definition: {
+            ...definition,
+            pattern: emailPattern,
+        },
+    }, (input, self) => {
+        if (!self.definition.pattern.test(input)) {
+            return error.SymbolDataParserErrorIssue;
+        }
+        return self.definition.normalize ? input.toLowerCase() : input;
+    });
+}
+function email(definition) {
+    return index.string({
+        checkers: [checkerEmail(definition)],
+    });
+}
+
+exports.checkerEmail = checkerEmail;
+exports.dataParserCheckerEmailKind = dataParserCheckerEmailKind;
+exports.email = email;

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

@@ -0,0 +1,17 @@
+import { type Kind } from "../../../../common";
+import { type DataParserChecker, type DataParserCheckerDefinition } from "../../../../dataParser/base";
+export interface DataParserCheckerDefinitionEmail extends DataParserCheckerDefinition {
+    normalize?: boolean;
+    pattern: RegExp;
+}
+export declare const dataParserCheckerEmailKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"data-parser-checker-email", unknown>>;
+type _DataParserCheckerEmail = (Kind<typeof dataParserCheckerEmailKind.definition> & DataParserChecker<DataParserCheckerDefinitionEmail, string>);
+export interface DataParserCheckerEmail extends _DataParserCheckerEmail {
+}
+export declare function checkerEmail(definition?: Partial<DataParserCheckerDefinitionEmail>): DataParserCheckerEmail;
+export declare function email(definition?: Partial<DataParserCheckerDefinitionEmail>): import("..").DataParserString<{
+    readonly checkers: readonly [DataParserCheckerEmail];
+    readonly errorMessage?: string | undefined;
+    readonly coerce: boolean;
+}>;
+export {};

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

@@ -0,0 +1,27 @@
+import { createKind } from '../../../../common/kind.mjs';
+import { dataParserCheckerInit } from '../../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+import { string } from '../index.mjs';
+
+const dataParserCheckerEmailKind = createKind("data-parser-checker-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, {
+        definition: {
+            ...definition,
+            pattern: emailPattern,
+        },
+    }, (input, self) => {
+        if (!self.definition.pattern.test(input)) {
+            return SymbolDataParserErrorIssue;
+        }
+        return self.definition.normalize ? input.toLowerCase() : input;
+    });
+}
+function email(definition) {
+    return string({
+        checkers: [checkerEmail(definition)],
+    });
+}
+
+export { checkerEmail, dataParserCheckerEmailKind, email };

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

@@ -0,0 +1,5 @@
+export * from "./url";
+export * from "./email";
+export * from "./max";
+export * from "./min";
+export * from "./regex";

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

@@ -0,0 +1,18 @@
+'use strict';
+
+var kind = require('../../../../common/kind.cjs');
+var base = require('../../../base.cjs');
+var error = require('../../../error.cjs');
+
+const dataParserCheckerStringMaxKind = kind.createKind("data-parser-checker-string-max");
+function checkerStringMax(max, definition = {}) {
+    return base.dataParserCheckerInit(dataParserCheckerStringMaxKind, {
+        definition: {
+            ...definition,
+            max,
+        },
+    }, (value, self) => value.length <= self.definition.max ? value : error.SymbolDataParserErrorIssue);
+}
+
+exports.checkerStringMax = checkerStringMax;
+exports.dataParserCheckerStringMaxKind = dataParserCheckerStringMaxKind;

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

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

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

@@ -0,0 +1,15 @@
+import { createKind } from '../../../../common/kind.mjs';
+import { dataParserCheckerInit } from '../../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+
+const dataParserCheckerStringMaxKind = createKind("data-parser-checker-string-max");
+function checkerStringMax(max, definition = {}) {
+    return dataParserCheckerInit(dataParserCheckerStringMaxKind, {
+        definition: {
+            ...definition,
+            max,
+        },
+    }, (value, self) => value.length <= self.definition.max ? value : SymbolDataParserErrorIssue);
+}
+
+export { checkerStringMax, dataParserCheckerStringMaxKind };

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

@@ -0,0 +1,18 @@
+'use strict';
+
+var kind = require('../../../../common/kind.cjs');
+var base = require('../../../base.cjs');
+var error = require('../../../error.cjs');
+
+const dataParserCheckerStringMinKind = kind.createKind("data-parser-checker-string-min");
+function checkerStringMin(min, definition = {}) {
+    return base.dataParserCheckerInit(dataParserCheckerStringMinKind, {
+        definition: {
+            ...definition,
+            min,
+        },
+    }, (value, self) => value.length >= self.definition.min ? value : error.SymbolDataParserErrorIssue);
+}
+
+exports.checkerStringMin = checkerStringMin;
+exports.dataParserCheckerStringMinKind = dataParserCheckerStringMinKind;

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

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

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

@@ -0,0 +1,15 @@
+import { createKind } from '../../../../common/kind.mjs';
+import { dataParserCheckerInit } from '../../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+
+const dataParserCheckerStringMinKind = createKind("data-parser-checker-string-min");
+function checkerStringMin(min, definition = {}) {
+    return dataParserCheckerInit(dataParserCheckerStringMinKind, {
+        definition: {
+            ...definition,
+            min,
+        },
+    }, (value, self) => value.length >= self.definition.min ? value : SymbolDataParserErrorIssue);
+}
+
+export { checkerStringMin, dataParserCheckerStringMinKind };

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

@@ -0,0 +1,20 @@
+'use strict';
+
+var kind = require('../../../../common/kind.cjs');
+var base = require('../../../base.cjs');
+var error = require('../../../error.cjs');
+
+const dataParserCheckerStringRegexKind = kind.createKind("data-parser-checker-string-regex");
+function checkerStringRegex(regex, definition = {}) {
+    return base.dataParserCheckerInit(dataParserCheckerStringRegexKind, {
+        definition: {
+            ...definition,
+            regex,
+        },
+    }, (value, self) => self.definition.regex.test(value)
+        ? value
+        : error.SymbolDataParserErrorIssue);
+}
+
+exports.checkerStringRegex = checkerStringRegex;
+exports.dataParserCheckerStringRegexKind = dataParserCheckerStringRegexKind;

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

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

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

@@ -0,0 +1,17 @@
+import { createKind } from '../../../../common/kind.mjs';
+import { dataParserCheckerInit } from '../../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+
+const dataParserCheckerStringRegexKind = createKind("data-parser-checker-string-regex");
+function checkerStringRegex(regex, definition = {}) {
+    return dataParserCheckerInit(dataParserCheckerStringRegexKind, {
+        definition: {
+            ...definition,
+            regex,
+        },
+    }, (value, self) => self.definition.regex.test(value)
+        ? value
+        : SymbolDataParserErrorIssue);
+}
+
+export { checkerStringRegex, dataParserCheckerStringRegexKind };

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

@@ -0,0 +1,48 @@
+'use strict';
+
+var kind = require('../../../../common/kind.cjs');
+var base = require('../../../base.cjs');
+var error = require('../../../error.cjs');
+var index = require('../index.cjs');
+
+const dataParserCheckerUrlKind = kind.createKind("data-parser-checker-url");
+const regexRemoveDote = /:$/;
+function checkerUrl(definition = {}) {
+    return base.dataParserCheckerInit(dataParserCheckerUrlKind, {
+        definition: definition,
+    }, (input, self) => {
+        try {
+            const url = new URL(input);
+            if (self.definition.hostname) {
+                self.definition.hostname.lastIndex = 0;
+                if (!self.definition.hostname.test(url.hostname)) {
+                    return error.SymbolDataParserErrorIssue;
+                }
+            }
+            if (self.definition.protocol) {
+                self.definition.protocol.lastIndex = 0;
+                if (!self.definition.protocol.test(url.protocol.replace(regexRemoveDote, ""))) {
+                    return error.SymbolDataParserErrorIssue;
+                }
+            }
+            if (self.definition.normalize) {
+                return url.href;
+            }
+            else {
+                return input;
+            }
+        }
+        catch {
+            return error.SymbolDataParserErrorIssue;
+        }
+    });
+}
+function url(definition) {
+    return index.string({
+        checkers: [checkerUrl(definition)],
+    });
+}
+
+exports.checkerUrl = checkerUrl;
+exports.dataParserCheckerUrlKind = dataParserCheckerUrlKind;
+exports.url = url;

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

@@ -0,0 +1,18 @@
+import { type Kind } from "../../../../common";
+import { type DataParserCheckerDefinition, type DataParserChecker } from "../../../../dataParser/base";
+export interface DataParserCheckerDefinitionUrl extends DataParserCheckerDefinition {
+    hostname?: RegExp;
+    protocol?: RegExp;
+    normalize?: boolean;
+}
+export declare const dataParserCheckerUrlKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"data-parser-checker-url", unknown>>;
+type _DataParserCheckerUrl = (Kind<typeof dataParserCheckerUrlKind.definition> & DataParserChecker<DataParserCheckerDefinitionUrl, string>);
+export interface DataParserCheckerUrl extends _DataParserCheckerUrl {
+}
+export declare function checkerUrl(definition?: Partial<DataParserCheckerDefinitionUrl>): DataParserCheckerUrl;
+export declare function url(definition?: Partial<DataParserCheckerDefinitionUrl>): import("..").DataParserString<{
+    readonly checkers: readonly [DataParserCheckerUrl];
+    readonly errorMessage?: string | undefined;
+    readonly coerce: boolean;
+}>;
+export {};

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

@@ -0,0 +1,44 @@
+import { createKind } from '../../../../common/kind.mjs';
+import { dataParserCheckerInit } from '../../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+import { string } from '../index.mjs';
+
+const dataParserCheckerUrlKind = createKind("data-parser-checker-url");
+const regexRemoveDote = /:$/;
+function checkerUrl(definition = {}) {
+    return dataParserCheckerInit(dataParserCheckerUrlKind, {
+        definition: definition,
+    }, (input, self) => {
+        try {
+            const url = new URL(input);
+            if (self.definition.hostname) {
+                self.definition.hostname.lastIndex = 0;
+                if (!self.definition.hostname.test(url.hostname)) {
+                    return SymbolDataParserErrorIssue;
+                }
+            }
+            if (self.definition.protocol) {
+                self.definition.protocol.lastIndex = 0;
+                if (!self.definition.protocol.test(url.protocol.replace(regexRemoveDote, ""))) {
+                    return SymbolDataParserErrorIssue;
+                }
+            }
+            if (self.definition.normalize) {
+                return url.href;
+            }
+            else {
+                return input;
+            }
+        }
+        catch {
+            return SymbolDataParserErrorIssue;
+        }
+    });
+}
+function url(definition) {
+    return string({
+        checkers: [checkerUrl(definition)],
+    });
+}
+
+export { checkerUrl, dataParserCheckerUrlKind, url };

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

@@ -0,0 +1,31 @@
+'use strict';
+
+var kind = require('../../../common/kind.cjs');
+var base = require('../../base.cjs');
+var error = require('../../error.cjs');
+
+const dataParserStringKind = kind.createKind("data-parser-string");
+function string(definition) {
+    return base.dataParserInit(dataParserStringKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            coerce: definition?.coerce ?? false,
+        },
+    }, (data, _error, self) => {
+        if (self.definition.coerce) {
+            try {
+                // eslint-disable-next-line no-param-reassign
+                data = String(data);
+            }
+            catch { }
+        }
+        if (typeof data === "string") {
+            return data;
+        }
+        return error.SymbolDataParserErrorIssue;
+    });
+}
+
+exports.dataParserStringKind = dataParserStringKind;
+exports.string = string;

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

@@ -0,0 +1,18 @@
+import { type NeverCoalescing, type Kind } from "../../../common";
+import { type DataParserDefinition, type DataParser } from "../../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../../dataParser/types";
+import { type DataParserCheckerUrl, type DataParserCheckerEmail, type DataParserCheckerStringMin, type DataParserCheckerStringMax, type DataParserCheckerStringRegex } from "./checkers";
+export * from "./checkers";
+export type DataParserStringCheckers = (DataParserCheckerUrl | DataParserCheckerEmail | DataParserCheckerStringMin | DataParserCheckerStringMax | DataParserCheckerStringRegex);
+export interface DataParserDefinitionString extends DataParserDefinition<DataParserStringCheckers> {
+    readonly coerce: boolean;
+}
+export declare const dataParserStringKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"data-parser-string", unknown>>;
+type _DataParserString<GenericDefinition extends DataParserDefinitionString> = (DataParser<GenericDefinition, string, string> & Kind<typeof dataParserStringKind.definition>);
+export interface DataParserString<GenericDefinition extends DataParserDefinitionString = DataParserDefinitionString> extends _DataParserString<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserStringCheckers,
+        ...DataParserStringCheckers[]
+    ]>(...args: 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/string/index.mjs

@@ -0,0 +1,28 @@
+import { createKind } from '../../../common/kind.mjs';
+import { dataParserInit } from '../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../error.mjs';
+
+const dataParserStringKind = createKind("data-parser-string");
+function string(definition) {
+    return dataParserInit(dataParserStringKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            coerce: definition?.coerce ?? false,
+        },
+    }, (data, _error, self) => {
+        if (self.definition.coerce) {
+            try {
+                // eslint-disable-next-line no-param-reassign
+                data = String(data);
+            }
+            catch { }
+        }
+        if (typeof data === "string") {
+            return data;
+        }
+        return SymbolDataParserErrorIssue;
+    });
+}
+
+export { dataParserStringKind, string };

package/dist/dataParser/parsers/templateLiteral.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+var escapeRegExp = require('../../common/escapeRegExp.cjs');
+var kind = require('../../common/kind.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 whenElse = require('../../common/whenElse.cjs');
+var map = require('../../array/map.cjs');
+var join = require('../../array/join.cjs');
+var base = require('../base.cjs');
+var error = require('../error.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 = require('./string/index.cjs');
+var index$2 = require('./number/index.cjs');
+var index$1 = require('./bigint/index.cjs');
+var literal = require('./literal.cjs');
+var empty = require('./empty.cjs');
+var nil = require('./nil.cjs');
+var boolean = require('./boolean.cjs');
+
+const dataParserTemplateLiteralKind = kind.createKind("data-parser-template-literal");
+function templateLiteral(template, definition) {
+    const pattern = pipe.pipe(template, map.map(innerPipe.innerPipe(when.when(isType.isType("string"), (value) => `(?:${escapeRegExp.escapeRegExp(value)})`), when.when(index$2.dataParserNumberKind.has, () => "(:?[0-9]+)"), when.when(index$1.dataParserBigIntKind.has, () => "(?:[0-9]+n)"), when.when(boolean.dataParserBooleanKind.has, () => "(?:true|false)"), when.when(nil.dataParserNilKind.has, () => "(?:null)"), when.when(empty.dataParserEmptyKind.has, () => "(?:undefined)"), when.when(literal.dataParserLiteralKind.has, (dataParser) => pipe.pipe(dataParser.definition.value, map.map(innerPipe.innerPipe(when$1.when(isType.isType("bigint"), (value) => `${value}n`), String, escapeRegExp.escapeRegExp)), join.join("|"), (pattern) => `(?:${pattern})`)), when.when(index.dataParserStringKind.has, innerPipe.innerPipe(whenElse.whenElse((dataParser) => !!dataParser.definition.checkers.length, (dataParser) => pipe.pipe(dataParser.definition.checkers, map.map((element) => pipe.pipe(element.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, ""))), join.join("")), () => "(?:[^]*)"))), when.when(dataParserTemplateLiteralKind.has, (dataParser) => pipe.pipe(dataParser.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, ""), (pattern) => `(?:${pattern})`)), exhaustive.exhaustive)), join.join(""), (pattern) => new RegExp(`^${pattern}$`));
+    return base.dataParserInit(dataParserTemplateLiteralKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            template,
+            pattern,
+        },
+    }, (data, _error, self) => {
+        if (typeof data === "string" && self.definition.pattern.test(data)) {
+            return data;
+        }
+        return error.SymbolDataParserErrorIssue;
+    });
+}
+
+exports.dataParserTemplateLiteralKind = dataParserTemplateLiteralKind;
+exports.templateLiteral = templateLiteral;

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

@@ -0,0 +1,49 @@
+import { type Adaptor, type Kind, type NeverCoalescing } from "../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input } from "../base";
+import { type MergeDefinition } from "../../dataParser/types";
+import { type DataParserCheckerEmail, type DataParserDefinitionString, type DataParserString } from "./string";
+import { type DataParserDefinitionNumber, type DataParserNumber } from "./number";
+import { type DataParserDefinitionBigInt, type DataParserBigInt } from "./bigint";
+import { type DataParserDefinitionLiteral, type DataParserLiteral } from "./literal";
+import { type DataParserDefinitionEmpty, type DataParserEmpty } from "./empty";
+import { type DataParserDefinitionNil, type DataParserNil } from "./nil";
+import { type DataParserDefinitionBoolean, type DataParserBoolean } from "./boolean";
+export type DataParsersTemplateLiteral = (string | DataParserString<DataParserDefinitionString & {
+    readonly checkers: readonly (DataParserCheckerEmail)[];
+}> | DataParserNumber<DataParserDefinitionNumber & {
+    readonly checkers: readonly [];
+}> | DataParserBigInt<DataParserDefinitionBigInt & {
+    readonly checkers: readonly [];
+}> | DataParserBoolean<DataParserDefinitionBoolean & {
+    readonly checkers: readonly [];
+}> | DataParserLiteral<DataParserDefinitionLiteral & {
+    readonly checkers: readonly [];
+}> | DataParserEmpty<DataParserDefinitionEmpty & {
+    readonly checkers: readonly [];
+}> | DataParserNil<DataParserDefinitionNil & {
+    readonly checkers: readonly [];
+}> | DataParserTemplateLiteral<DataParserDefinitionTemplateLiteral & {
+    readonly checkers: readonly [];
+}>);
+export type TemplateLiteralShape = readonly [DataParsersTemplateLiteral, ...DataParsersTemplateLiteral[]];
+type EligibleTemplateLiteral = string | number | bigint | boolean | null | undefined;
+export type TemplateLiteralShapeOutput<GenericTemplate extends TemplateLiteralShape, GenericLastResult extends string = ""> = GenericTemplate extends readonly [
+    infer InferredFirst extends DataParsersTemplateLiteral,
+    ...infer InferredRest extends DataParsersTemplateLiteral[]
+] ? (`${GenericLastResult}${InferredFirst extends string ? InferredFirst : Adaptor<Output<Exclude<InferredFirst, string>>, EligibleTemplateLiteral>}`) extends infer InferredResult extends string ? InferredRest extends readonly [] ? InferredResult : InferredRest extends TemplateLiteralShape ? TemplateLiteralShapeOutput<InferredRest, InferredResult> : TemplateLiteralShapeOutput<[InferredRest[number]], InferredResult> : never : never;
+export type TemplateLiteralShapeInput<GenericTemplate extends TemplateLiteralShape, GenericLastResult extends string = ""> = GenericTemplate extends readonly [
+    infer InferredFirst extends DataParsersTemplateLiteral,
+    ...infer InferredRest extends DataParsersTemplateLiteral[]
+] ? (`${GenericLastResult}${InferredFirst extends string ? InferredFirst : Adaptor<Input<Exclude<InferredFirst, string>>, EligibleTemplateLiteral>}`) extends infer InferredResult extends string ? InferredRest extends readonly [] ? InferredResult : InferredRest extends TemplateLiteralShape ? TemplateLiteralShapeInput<InferredRest, InferredResult> : TemplateLiteralShapeInput<[InferredRest[number]], InferredResult> : never : never;
+export interface DataParserDefinitionTemplateLiteral extends DataParserDefinition<never> {
+    readonly template: TemplateLiteralShape;
+    readonly pattern: RegExp;
+}
+export declare const dataParserTemplateLiteralKind: import("../../common").KindHandler<import("../../common").KindDefinition<"data-parser-template-literal", unknown>>;
+type _DataParserTemplateLiteral<GenericDefinition extends DataParserDefinitionTemplateLiteral> = (DataParser<GenericDefinition, TemplateLiteralShapeOutput<GenericDefinition["template"]>, TemplateLiteralShapeInput<GenericDefinition["template"]>> & Kind<typeof dataParserTemplateLiteralKind.definition>);
+export interface DataParserTemplateLiteral<GenericDefinition extends DataParserDefinitionTemplateLiteral = DataParserDefinitionTemplateLiteral> extends _DataParserTemplateLiteral<GenericDefinition> {
+}
+export declare function templateLiteral<const GenericTemplate extends TemplateLiteralShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionTemplateLiteral, "template" | "pattern">> = never>(template: GenericTemplate, definition?: GenericDefinition): DataParserTemplateLiteral<MergeDefinition<DataParserDefinitionTemplateLiteral, NeverCoalescing<GenericDefinition, {}> & {
+    template: GenericTemplate;
+}>>;
+export {};