@duplojs/utils 1.0.6 → 1.1.7

package/dist/dataParser/parsers/templateLiteral.mjs

@@ -0,0 +1,42 @@
+import { escapeRegExp } from '../../common/escapeRegExp.mjs';
+import { createKind } from '../../common/kind.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 { 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 { dataParserStringKind } from './string/index.mjs';
+import { dataParserNumberKind } from './number/index.mjs';
+import { dataParserBigIntKind } from './bigint/index.mjs';
+import { dataParserLiteralKind } from './literal.mjs';
+import { dataParserEmptyKind } from './empty.mjs';
+import { dataParserNilKind } from './nil.mjs';
+import { dataParserBooleanKind } from './boolean.mjs';
+
+const dataParserTemplateLiteralKind = createKind("data-parser-template-literal");
+function templateLiteral(template, definition) {
+    const pattern = pipe(template, map(innerPipe(when(isType("string"), (value) => `(?:${escapeRegExp(value)})`), when(dataParserNumberKind.has, () => "(:?[0-9]+)"), when(dataParserBigIntKind.has, () => "(?:[0-9]+n)"), when(dataParserBooleanKind.has, () => "(?:true|false)"), when(dataParserNilKind.has, () => "(?:null)"), when(dataParserEmptyKind.has, () => "(?:undefined)"), when(dataParserLiteralKind.has, (dataParser) => pipe(dataParser.definition.value, map(innerPipe(when$1(isType("bigint"), (value) => `${value}n`), String, escapeRegExp)), join("|"), (pattern) => `(?:${pattern})`)), when(dataParserStringKind.has, innerPipe(whenElse((dataParser) => !!dataParser.definition.checkers.length, (dataParser) => pipe(dataParser.definition.checkers, map((element) => pipe(element.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, ""))), join("")), () => "(?:[^]*)"))), when(dataParserTemplateLiteralKind.has, (dataParser) => pipe(dataParser.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, ""), (pattern) => `(?:${pattern})`)), exhaustive)), join(""), (pattern) => new RegExp(`^${pattern}$`));
+    return 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 SymbolDataParserErrorIssue;
+    });
+}
+
+export { dataParserTemplateLiteralKind, templateLiteral };

package/dist/dataParser/parsers/transform.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var base = require('../base.cjs');
+var error = require('../error.cjs');
+
+const dataParserTransformKind = kind.createKind("data-parser-transform");
+function transform(inner, theFunction, definition) {
+    return base.dataParserInit(dataParserTransformKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            inner,
+            theFunction,
+        },
+    }, {
+        sync: (data, error$1, self) => {
+            const innerResult = self.definition.inner.exec(data, error$1);
+            if (innerResult === base.SymbolDataParserError) {
+                return base.SymbolDataParserError;
+            }
+            const result = self.definition.theFunction(innerResult, error$1);
+            if (result instanceof Promise) {
+                return error.SymbolDataParserErrorPromiseIssue;
+            }
+            return result;
+        },
+        async: async (data, error$1, self) => {
+            const innerResult = await self.definition.inner.asyncExec(data, error$1);
+            if (innerResult === base.SymbolDataParserError) {
+                return base.SymbolDataParserError;
+            }
+            let result = self.definition.theFunction(innerResult, error$1);
+            if (result instanceof Promise) {
+                result = result.catch(() => error.SymbolDataParserErrorPromiseIssue);
+            }
+            return result;
+        },
+    });
+}
+
+exports.dataParserTransformKind = dataParserTransformKind;
+exports.transform = transform;

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

@@ -0,0 +1,17 @@
+import { type Kind, type NeverCoalescing } from "../../common";
+import { type DataParserDefinition, type DataParser, type Input, type Output, SymbolDataParserError } from "../base";
+import { type DataParsers, type MergeDefinition } from "../../dataParser/types";
+import { type DataParserError, type SymbolDataParserErrorIssue, SymbolDataParserErrorPromiseIssue } from "../../dataParser/error";
+export interface DataParserDefinitionTransform extends DataParserDefinition<never> {
+    readonly inner: DataParsers;
+    theFunction(input: any, error: DataParserError): unknown;
+}
+export declare const dataParserTransformKind: import("../../common").KindHandler<import("../../common").KindDefinition<"data-parser-transform", unknown>>;
+type _DataParserTransform<GenericDefinition extends DataParserDefinitionTransform> = (DataParser<GenericDefinition, Exclude<Awaited<ReturnType<GenericDefinition["theFunction"]>>, SymbolDataParserError | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue>, Input<GenericDefinition["inner"]>> & Kind<typeof dataParserTransformKind.definition>);
+export interface DataParserTransform<GenericDefinition extends DataParserDefinitionTransform = DataParserDefinitionTransform> extends _DataParserTransform<GenericDefinition> {
+}
+export declare function transform<GenericDataParser extends DataParsers, GenericOutput extends unknown, const GenericDefinition extends Partial<Omit<DataParserDefinitionTransform, "inner" | "theFunction">> = never>(inner: GenericDataParser, theFunction: (input: Output<GenericDataParser>, error: DataParserError) => GenericOutput, definition?: GenericDefinition): DataParserTransform<MergeDefinition<DataParserDefinitionTransform, NeverCoalescing<GenericDefinition, {}> & {
+    inner: GenericDataParser;
+    theFunction(input: Output<GenericDataParser>): GenericOutput;
+}>>;
+export {};

package/dist/dataParser/parsers/transform.mjs

@@ -0,0 +1,40 @@
+import { createKind } from '../../common/kind.mjs';
+import { dataParserInit, SymbolDataParserError } from '../base.mjs';
+import { SymbolDataParserErrorPromiseIssue } from '../error.mjs';
+
+const dataParserTransformKind = createKind("data-parser-transform");
+function transform(inner, theFunction, definition) {
+    return dataParserInit(dataParserTransformKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            inner,
+            theFunction,
+        },
+    }, {
+        sync: (data, error, self) => {
+            const innerResult = self.definition.inner.exec(data, error);
+            if (innerResult === SymbolDataParserError) {
+                return SymbolDataParserError;
+            }
+            const result = self.definition.theFunction(innerResult, error);
+            if (result instanceof Promise) {
+                return SymbolDataParserErrorPromiseIssue;
+            }
+            return result;
+        },
+        async: async (data, error, self) => {
+            const innerResult = await self.definition.inner.asyncExec(data, error);
+            if (innerResult === SymbolDataParserError) {
+                return SymbolDataParserError;
+            }
+            let result = self.definition.theFunction(innerResult, error);
+            if (result instanceof Promise) {
+                result = result.catch(() => SymbolDataParserErrorPromiseIssue);
+            }
+            return result;
+        },
+    });
+}
+
+export { dataParserTransformKind, transform };

package/dist/dataParser/parsers/tuple.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var base = require('../base.cjs');
+var error = require('../error.cjs');
+
+const dataParserTupleKind = kind.createKind("data-parser-tuple");
+function tuple(shape, definition) {
+    return base.dataParserInit(dataParserTupleKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            rest: definition?.rest,
+            shape,
+        },
+    }, {
+        sync: (data, error$1, self) => {
+            if (!(data instanceof Array)) {
+                return error.SymbolDataParserErrorIssue;
+            }
+            let output = [];
+            const currentIndexPath = error$1.currentPath.length;
+            for (let index = 0; index < self.definition.shape.length; index++) {
+                error.setErrorPath(error$1, `[${index}]`, currentIndexPath);
+                const result = self.definition.shape[index]?.exec(data[index], error$1);
+                if (result === base.SymbolDataParserError) {
+                    output = base.SymbolDataParserError;
+                }
+                else if (output !== base.SymbolDataParserError) {
+                    output.push(result);
+                }
+            }
+            if (self.definition.rest) {
+                for (let index = self.definition.shape.length; index < data.length; index++) {
+                    error.setErrorPath(error$1, `[${index}]`, currentIndexPath);
+                    const result = self.definition.rest.exec(data[index], error$1);
+                    if (result === base.SymbolDataParserError) {
+                        output = base.SymbolDataParserError;
+                    }
+                    else if (output !== base.SymbolDataParserError) {
+                        output.push(result);
+                    }
+                }
+            }
+            error.popErrorPath(error$1);
+            return output;
+        },
+        async: async (data, error$1, self) => {
+            if (!(data instanceof Array)) {
+                return error.SymbolDataParserErrorIssue;
+            }
+            let output = [];
+            const currentIndexPath = error$1.currentPath.length;
+            for (let index = 0; index < self.definition.shape.length; index++) {
+                error.setErrorPath(error$1, `[${index}]`, currentIndexPath);
+                const result = await self.definition.shape[index]?.asyncExec(data[index], error$1);
+                if (result === base.SymbolDataParserError) {
+                    output = base.SymbolDataParserError;
+                }
+                else if (output !== base.SymbolDataParserError) {
+                    output.push(result);
+                }
+            }
+            if (self.definition?.rest) {
+                for (let index = self.definition.shape.length; index < data.length; index++) {
+                    error.setErrorPath(error$1, `[${index}]`, currentIndexPath);
+                    const result = await self.definition.rest.asyncExec(data[index], error$1);
+                    if (result === base.SymbolDataParserError) {
+                        output = base.SymbolDataParserError;
+                    }
+                    else if (output !== base.SymbolDataParserError) {
+                        output.push(result);
+                    }
+                }
+            }
+            error.popErrorPath(error$1);
+            return output;
+        },
+    });
+}
+
+exports.dataParserTupleKind = dataParserTupleKind;
+exports.tuple = tuple;

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

@@ -0,0 +1,33 @@
+import { type UnionContain, type IsEqual, type Kind, type Adaptor, type NeverCoalescing } from "../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input } from "../base";
+import { type AddCheckersToDefinition, type DataParsers, type MergeDefinition } from "../../dataParser/types";
+import { type DataParserCheckerArrayMax, type DataParserCheckerArrayMin } from "./array";
+export type TupleShape = readonly [DataParsers, ...DataParsers[]];
+export type DataParserTupleShapeOutput<GenericShape extends TupleShape, GenericRest extends DataParsers | undefined> = IsEqual<GenericShape, TupleShape> extends true ? TupleShape : GenericShape extends [
+    infer InferredFirst extends DataParsers,
+    ...infer InferredRest extends DataParsers[]
+] ? [
+    Output<InferredFirst>,
+    ...(InferredRest extends TupleShape ? DataParserTupleShapeOutput<InferredRest, GenericRest> : UnionContain<GenericRest, undefined> extends true ? [] : Output<Adaptor<GenericRest, DataParser>>[])
+] : never;
+export type DataParserTupleShapeInput<GenericShape extends TupleShape, GenericRest extends DataParsers | undefined> = IsEqual<GenericShape, TupleShape> extends true ? TupleShape : GenericShape extends [
+    infer InferredFirst extends DataParsers,
+    ...infer InferredRest extends DataParsers[]
+] ? [
+    Input<InferredFirst>,
+    ...(InferredRest extends TupleShape ? DataParserTupleShapeOutput<InferredRest, GenericRest> : UnionContain<GenericRest, undefined> extends true ? [] : Input<Adaptor<GenericRest, DataParser>>[])
+] : never;
+export type DataParserTupleCheckers = (DataParserCheckerArrayMin | DataParserCheckerArrayMax);
+export interface DataParserDefinitionTuple extends DataParserDefinition<DataParserTupleCheckers> {
+    readonly shape: TupleShape;
+    readonly rest?: DataParsers;
+}
+export declare const dataParserTupleKind: import("../../common").KindHandler<import("../../common").KindDefinition<"data-parser-tuple", unknown>>;
+type _DataParserTuple<GenericDefinition extends DataParserDefinitionTuple> = (DataParser<GenericDefinition, DataParserTupleShapeOutput<GenericDefinition["shape"], GenericDefinition["rest"]>, DataParserTupleShapeInput<GenericDefinition["shape"], GenericDefinition["rest"]>> & Kind<typeof dataParserTupleKind.definition>);
+export interface DataParserTuple<GenericDefinition extends DataParserDefinitionTuple = DataParserDefinitionTuple> extends _DataParserTuple<GenericDefinition> {
+    addChecker<GenericChecker extends [DataParserTupleCheckers, ...DataParserTupleCheckers[]]>(...args: GenericChecker): DataParserTuple<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+}
+export declare function tuple<GenericShape extends TupleShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionTuple, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserTuple<MergeDefinition<DataParserDefinitionTuple, NeverCoalescing<GenericDefinition, {}> & {
+    shape: GenericShape;
+}>>;
+export {};

package/dist/dataParser/parsers/tuple.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 dataParserTupleKind = createKind("data-parser-tuple");
+function tuple(shape, definition) {
+    return dataParserInit(dataParserTupleKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            rest: definition?.rest,
+            shape,
+        },
+    }, {
+        sync: (data, error, self) => {
+            if (!(data instanceof Array)) {
+                return SymbolDataParserErrorIssue;
+            }
+            let output = [];
+            const currentIndexPath = error.currentPath.length;
+            for (let index = 0; index < self.definition.shape.length; index++) {
+                setErrorPath(error, `[${index}]`, currentIndexPath);
+                const result = self.definition.shape[index]?.exec(data[index], error);
+                if (result === SymbolDataParserError) {
+                    output = SymbolDataParserError;
+                }
+                else if (output !== SymbolDataParserError) {
+                    output.push(result);
+                }
+            }
+            if (self.definition.rest) {
+                for (let index = self.definition.shape.length; index < data.length; index++) {
+                    setErrorPath(error, `[${index}]`, currentIndexPath);
+                    const result = self.definition.rest.exec(data[index], error);
+                    if (result === SymbolDataParserError) {
+                        output = SymbolDataParserError;
+                    }
+                    else if (output !== SymbolDataParserError) {
+                        output.push(result);
+                    }
+                }
+            }
+            popErrorPath(error);
+            return output;
+        },
+        async: async (data, error, self) => {
+            if (!(data instanceof Array)) {
+                return SymbolDataParserErrorIssue;
+            }
+            let output = [];
+            const currentIndexPath = error.currentPath.length;
+            for (let index = 0; index < self.definition.shape.length; index++) {
+                setErrorPath(error, `[${index}]`, currentIndexPath);
+                const result = await self.definition.shape[index]?.asyncExec(data[index], error);
+                if (result === SymbolDataParserError) {
+                    output = SymbolDataParserError;
+                }
+                else if (output !== SymbolDataParserError) {
+                    output.push(result);
+                }
+            }
+            if (self.definition?.rest) {
+                for (let index = self.definition.shape.length; index < data.length; index++) {
+                    setErrorPath(error, `[${index}]`, currentIndexPath);
+                    const result = await self.definition.rest.asyncExec(data[index], error);
+                    if (result === SymbolDataParserError) {
+                        output = SymbolDataParserError;
+                    }
+                    else if (output !== SymbolDataParserError) {
+                        output.push(result);
+                    }
+                }
+            }
+            popErrorPath(error);
+            return output;
+        },
+    });
+}
+
+export { dataParserTupleKind, tuple };

package/dist/dataParser/parsers/union.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var base = require('../base.cjs');
+var error = require('../error.cjs');
+
+const dataParserUnionKind = kind.createKind("data-parser-union");
+function union(options, definition) {
+    return base.dataParserInit(dataParserUnionKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            options,
+        },
+    }, {
+        sync: (data, error$1, self) => {
+            for (const dataParser of self.definition.options) {
+                const result = dataParser.exec(data, error$1);
+                if (result !== base.SymbolDataParserError) {
+                    return result;
+                }
+            }
+            return error.SymbolDataParserErrorIssue;
+        },
+        async: async (data, error$1, self) => {
+            for (const dataParser of self.definition.options) {
+                const result = await dataParser.asyncExec(data, error$1);
+                if (result !== base.SymbolDataParserError) {
+                    return result;
+                }
+            }
+            return error.SymbolDataParserErrorIssue;
+        },
+    });
+}
+
+exports.dataParserUnionKind = dataParserUnionKind;
+exports.union = union;

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

@@ -0,0 +1,15 @@
+import { type NeverCoalescing, type Kind } from "../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input } from "../base";
+import { type DataParsers, type MergeDefinition } from "../../dataParser/types";
+export type UnionOptions = readonly [DataParsers, ...DataParsers[]];
+export interface DataParserDefinitionUnion extends DataParserDefinition<never> {
+    readonly options: UnionOptions;
+}
+export declare const dataParserUnionKind: import("../../common").KindHandler<import("../../common").KindDefinition<"data-parser-union", unknown>>;
+type _DataParserUnion<GenericDefinition extends DataParserDefinitionUnion> = (DataParser<GenericDefinition, Output<GenericDefinition["options"][number]>, Input<GenericDefinition["options"][number]>> & Kind<typeof dataParserUnionKind.definition>);
+export interface DataParserUnion<GenericDefinition extends DataParserDefinitionUnion = DataParserDefinitionUnion> extends _DataParserUnion<GenericDefinition> {
+}
+export declare function union<GenericOptions extends UnionOptions, const GenericDefinition extends Partial<Omit<DataParserDefinitionUnion, "options">> = never>(options: GenericOptions, definition?: GenericDefinition): DataParserUnion<MergeDefinition<DataParserDefinitionUnion, NeverCoalescing<GenericDefinition, {}> & {
+    options: GenericOptions;
+}>>;
+export {};

package/dist/dataParser/parsers/union.mjs

@@ -0,0 +1,35 @@
+import { createKind } from '../../common/kind.mjs';
+import { dataParserInit, SymbolDataParserError } from '../base.mjs';
+import { SymbolDataParserErrorIssue } from '../error.mjs';
+
+const dataParserUnionKind = createKind("data-parser-union");
+function union(options, definition) {
+    return dataParserInit(dataParserUnionKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            options,
+        },
+    }, {
+        sync: (data, error, self) => {
+            for (const dataParser of self.definition.options) {
+                const result = dataParser.exec(data, error);
+                if (result !== SymbolDataParserError) {
+                    return result;
+                }
+            }
+            return SymbolDataParserErrorIssue;
+        },
+        async: async (data, error, self) => {
+            for (const dataParser of self.definition.options) {
+                const result = await dataParser.asyncExec(data, error);
+                if (result !== SymbolDataParserError) {
+                    return result;
+                }
+            }
+            return SymbolDataParserErrorIssue;
+        },
+    });
+}
+
+export { dataParserUnionKind, union };

package/dist/dataParser/parsers/unknown.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var base = require('../base.cjs');
+
+const dataParserUnknownKind = kind.createKind("data-parser-unknown");
+function unknown(definition) {
+    return base.dataParserInit(dataParserUnknownKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+        },
+    }, (data) => data);
+}
+
+exports.dataParserUnknownKind = dataParserUnknownKind;
+exports.unknown = unknown;

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

@@ -0,0 +1,11 @@
+import { type NeverCoalescing, type Kind } from "../../common";
+import { type DataParserDefinition, type DataParser } from "../base";
+import { type MergeDefinition } from "../../dataParser/types";
+export interface DataParserDefinitionUnknown extends DataParserDefinition<never> {
+}
+export declare const dataParserUnknownKind: import("../../common").KindHandler<import("../../common").KindDefinition<"data-parser-unknown", unknown>>;
+type _DataParserUnknown<GenericDefinition extends DataParserDefinitionUnknown> = (DataParser<GenericDefinition, unknown, unknown> & Kind<typeof dataParserUnknownKind.definition>);
+export interface DataParserUnknown<GenericDefinition extends DataParserDefinitionUnknown = DataParserDefinitionUnknown> extends _DataParserUnknown<GenericDefinition> {
+}
+export declare function unknown<const GenericDefinition extends Partial<DataParserDefinitionUnknown> = never>(definition?: GenericDefinition): DataParserUnknown<MergeDefinition<DataParserDefinitionUnknown, NeverCoalescing<GenericDefinition, {}>>>;
+export {};

package/dist/dataParser/parsers/unknown.mjs

@@ -0,0 +1,14 @@
+import { createKind } from '../../common/kind.mjs';
+import { dataParserInit } from '../base.mjs';
+
+const dataParserUnknownKind = createKind("data-parser-unknown");
+function unknown(definition) {
+    return dataParserInit(dataParserUnknownKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+        },
+    }, (data) => data);
+}
+
+export { dataParserUnknownKind, unknown };

package/dist/dataParser/types/addCheckersToDefinition.d.ts

@@ -0,0 +1,5 @@
+import { type AnyTuple, type SimplifyTopLevel } from "../../common";
+import { type DataParserChecker, type DataParserDefinition } from "../base";
+export type AddCheckersToDefinition<GenericDefinition extends DataParserDefinition, GenericChecker extends readonly [DataParserChecker, ...DataParserChecker[]]> = SimplifyTopLevel<Omit<GenericDefinition, "checkers"> & {
+    readonly checkers: GenericDefinition["checkers"] extends AnyTuple ? readonly [...GenericDefinition["checkers"], ...GenericChecker] : GenericChecker;
+}>;

package/dist/dataParser/types/checkers.d.ts

@@ -0,0 +1,3 @@
+import { type DataParserChecker } from "../base";
+import type * as AllDataParser from "../parsers";
+export type Checkers = (DataParserChecker | AllDataParser.DataParserCheckerUrl | AllDataParser.DataParserCheckerArrayMax | AllDataParser.DataParserCheckerArrayMin | AllDataParser.DataParserCheckerBigIntMax | AllDataParser.DataParserCheckerBigIntMin | AllDataParser.DataParserCheckerNumberMax | AllDataParser.DataParserCheckerNumberMin | AllDataParser.DataParserCheckerInt | AllDataParser.DataParserCheckerEmail);

package/dist/dataParser/types/dataParsers.d.ts

@@ -0,0 +1,5 @@
+import { type DataParser } from "../base";
+import type * as AllDataParser from "../parsers";
+export interface DataParserCustom {
+}
+export type DataParsers = (DataParserCustom[keyof DataParserCustom] | DataParser | AllDataParser.DataParserString | AllDataParser.DataParserObject | AllDataParser.DataParserNumber | AllDataParser.DataParserLiteral | AllDataParser.DataParserUnion | AllDataParser.DataParserArray | AllDataParser.DataParserBigInt | AllDataParser.DataParserTuple | AllDataParser.DataParserTransform | AllDataParser.DataParserBoolean | AllDataParser.DataParserNil | AllDataParser.DataParserEmpty | AllDataParser.DataParserTemplateLiteral | AllDataParser.DataParserPipe | AllDataParser.DataParserNullable | AllDataParser.DataParserOptional | AllDataParser.DataParserLazy | AllDataParser.DataParserUnknown | AllDataParser.DataParserRecord);

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

@@ -0,0 +1,4 @@
+export * from "./mergeDefinition";
+export * from "./dataParsers";
+export * from "./checkers";
+export * from "./addCheckersToDefinition";

package/dist/dataParser/types/mergeDefinition.d.ts

@@ -0,0 +1,5 @@
+import { type UnionContain, type SimplifyTopLevel } from "../../common";
+import { type DataParserCheckerDefinition, type DataParserDefinition } from "../base";
+export type MergeDefinition<GenericDefinition extends DataParserDefinition | DataParserCheckerDefinition, GenericPartialDefinition extends Partial<GenericDefinition>> = SimplifyTopLevel<Readonly<GenericPartialDefinition & Omit<GenericDefinition, keyof GenericPartialDefinition | "checkers"> & (UnionContain<keyof GenericPartialDefinition, "checkers"> extends true ? {} : {
+    checkers: readonly [];
+})>> extends infer InferredResult extends GenericDefinition ? InferredResult : never;

package/dist/either/bool/falsy.cjs

@@ -10,7 +10,7 @@ var base = require('./base.cjs');
 
 const eitherBoolFalsyKind = kind.createKind("either-bool-falsy");
 function boolFalsy(value = undefined) {
-    return base.eitherBoolKind.addTo(eitherBoolFalsyKind.addTo(create.left("bool", value)));
+    return base.eitherBoolKind.setTo(eitherBoolFalsyKind.setTo(create.left("bool", value)));
 }
 function isBoolFalsy(input) {
     return is.isLeft(input)

package/dist/either/bool/falsy.d.ts

@@ -1,4 +1,4 @@
-import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type EitherLeft } from "../left";
 import { type EitherRight } from "../right";
 import { bool } from "./create";
@@ -13,6 +13,6 @@ export declare function boolFalsy<const GenericValue extends BoolFalsyValue = un
 type Either = EitherRight | EitherLeft;
 export declare function isBoolFalsy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherBoolFalsy>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof bool<GenericValue>>;
-export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolFalsy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolFalsy>;
+export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolFalsy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherBoolFalsy>;
 export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolFalsy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolFalsy>;
 export {};

package/dist/either/bool/falsy.mjs

@@ -8,7 +8,7 @@ import { eitherBoolKind } from './base.mjs';
 
 const eitherBoolFalsyKind = createKind("either-bool-falsy");
 function boolFalsy(value = undefined) {
-    return eitherBoolKind.addTo(eitherBoolFalsyKind.addTo(left("bool", value)));
+    return eitherBoolKind.setTo(eitherBoolFalsyKind.setTo(left("bool", value)));
 }
 function isBoolFalsy(input) {
     return isLeft(input)

package/dist/either/bool/truthy.cjs

@@ -10,7 +10,7 @@ var base = require('./base.cjs');
 
 const eitherBoolTruthyKind = kind.createKind("either-bool-truthy");
 function boolTruthy(value) {
-    return base.eitherBoolKind.addTo(eitherBoolTruthyKind.addTo(create.right("bool", value)));
+    return base.eitherBoolKind.setTo(eitherBoolTruthyKind.setTo(create.right("bool", value)));
 }
 function isBoolTruthy(input) {
     return is.isRight(input)

package/dist/either/bool/truthy.d.ts

@@ -2,7 +2,7 @@ import { type EitherRight } from "../right";
 import { bool } from "./create";
 import { type EitherLeft } from "../left";
 import { type Kind } from "../../common/kind";
-import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { eitherBoolKind } from "./base";
 export declare const eitherBoolTruthyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-bool-truthy", unknown>>;
 type _EitherBoolTruthy<GenericValue extends unknown = unknown> = (EitherRight<"bool", GenericValue> & Kind<typeof eitherBoolKind.definition> & Kind<typeof eitherBoolTruthyKind.definition>);
@@ -12,6 +12,6 @@ export declare function boolTruthy<const GenericValue extends unknown>(value: Ge
 type Either = EitherRight | EitherLeft;
 export declare function isBoolTruthy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherBoolTruthy>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof bool<GenericValue>>;
-export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolTruthy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolTruthy>;
+export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolTruthy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherBoolTruthy>;
 export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolTruthy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolTruthy>;
 export {};

package/dist/either/bool/truthy.mjs

@@ -8,7 +8,7 @@ import { eitherBoolKind } from './base.mjs';
 
 const eitherBoolTruthyKind = createKind("either-bool-truthy");
 function boolTruthy(value) {
-    return eitherBoolKind.addTo(eitherBoolTruthyKind.addTo(right("bool", value)));
+    return eitherBoolKind.setTo(eitherBoolTruthyKind.setTo(right("bool", value)));
 }
 function isBoolTruthy(input) {
     return isRight(input)

package/dist/either/future/error.cjs

@@ -6,7 +6,7 @@ var base = require('./base.cjs');
 
 const eitherFutureErrorKind = kind.createKind("either-future-error");
 function futureError(value) {
-    return base.eitherFutureKind.addTo(eitherFutureErrorKind.addTo(create.left("future", value)));
+    return base.eitherFutureKind.setTo(eitherFutureErrorKind.setTo(create.left("future", value)));
 }
 
 exports.eitherFutureErrorKind = eitherFutureErrorKind;

package/dist/either/future/error.mjs

@@ -4,7 +4,7 @@ import { eitherFutureKind } from './base.mjs';
 
 const eitherFutureErrorKind = createKind("either-future-error");
 function futureError(value) {
-    return eitherFutureKind.addTo(eitherFutureErrorKind.addTo(left("future", value)));
+    return eitherFutureKind.setTo(eitherFutureErrorKind.setTo(left("future", value)));
 }
 
 export { eitherFutureErrorKind, futureError };

package/dist/either/future/success.cjs

@@ -6,7 +6,7 @@ var create = require('../right/create.cjs');
 
 const eitherFutureSuccessKind = kind.createKind("either-future-success");
 function futureSuccess(value) {
-    return base.eitherFutureKind.addTo(eitherFutureSuccessKind.addTo(create.right("future", value)));
+    return base.eitherFutureKind.setTo(eitherFutureSuccessKind.setTo(create.right("future", value)));
 }
 
 exports.eitherFutureSuccessKind = eitherFutureSuccessKind;

package/dist/either/future/success.mjs

@@ -4,7 +4,7 @@ import { right } from '../right/create.mjs';
 
 const eitherFutureSuccessKind = createKind("either-future-success");
 function futureSuccess(value) {
-    return eitherFutureKind.addTo(eitherFutureSuccessKind.addTo(right("future", value)));
+    return eitherFutureKind.setTo(eitherFutureSuccessKind.setTo(right("future", value)));
 }
 
 export { eitherFutureSuccessKind, futureSuccess };