@duplojs/utils 1.1.13 → 1.1.14

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

@@ -1,49 +0,0 @@
-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 templateLiteralKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/template-literal", unknown>>;
-type _DataParserTemplateLiteral<GenericDefinition extends DataParserDefinitionTemplateLiteral> = (DataParser<GenericDefinition, TemplateLiteralShapeOutput<GenericDefinition["template"]>, TemplateLiteralShapeInput<GenericDefinition["template"]>> & Kind<typeof templateLiteralKind.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 {};

package/dist/dataParser/parsers/templateLiteral.mjs

@@ -1,44 +0,0 @@
-import { escapeRegExp } from '../../common/escapeRegExp.mjs';
-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 { whenElse } from '../../common/whenElse.mjs';
-import { map } from '../../array/map.mjs';
-import { join } from '../../array/join.mjs';
-import '../../common/globalStore.mjs';
-import '../../common/builder.mjs';
-import { dataParserInit } from '../base.mjs';
-import { SymbolDataParserErrorIssue } from '../error.mjs';
-import '../../pattern/result.mjs';
-import { exhaustive } from '../../pattern/exhaustive.mjs';
-import { when } from '../../pattern/when.mjs';
-import { replace } from '../../string/replace.mjs';
-import { stringKind } from './string/index.mjs';
-import { numberKind } from './number/index.mjs';
-import { bigIntKind } from './bigint/index.mjs';
-import { literalKind } from './literal.mjs';
-import { emptyKind } from './empty.mjs';
-import { nilKind } from './nil.mjs';
-import { booleanKind } from './boolean.mjs';
-import { createDataParserKind } from '../kind.mjs';
-
-const templateLiteralKind = createDataParserKind("template-literal");
-function templateLiteral(template, definition) {
-    const pattern = pipe(template, map(innerPipe(when(isType("string"), (value) => `(?:${escapeRegExp(value)})`), when(numberKind.has, () => "(:?[0-9]+)"), when(bigIntKind.has, () => "(?:[0-9]+n)"), when(booleanKind.has, () => "(?:true|false)"), when(nilKind.has, () => "(?:null)"), when(emptyKind.has, () => "(?:undefined)"), when(literalKind.has, (dataParser) => pipe(dataParser.definition.value, map(innerPipe(when$1(isType("bigint"), (value) => `${value}n`), String, escapeRegExp)), join("|"), (pattern) => `(?:${pattern})`)), when(stringKind.has, innerPipe(whenElse((dataParser) => !!dataParser.definition.checkers.length, (dataParser) => pipe(dataParser.definition.checkers, map((element) => pipe(element.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, ""))), join("")), () => "(?:[^]*)"))), when(templateLiteralKind.has, (dataParser) => pipe(dataParser.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, ""), (pattern) => `(?:${pattern})`)), exhaustive)), join(""), (pattern) => new RegExp(`^${pattern}$`));
-    return dataParserInit(templateLiteralKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            template,
-            pattern,
-        },
-    }, (data, _error, self) => {
-        if (typeof data === "string" && self.definition.pattern.test(data)) {
-            return data;
-        }
-        return SymbolDataParserErrorIssue;
-    });
-}
-
-export { templateLiteral, templateLiteralKind };