@duplojs/utils 1.0.7 → 1.1.8

package/dist/array/coalescing.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+function coalescing(value) {
+    return value instanceof Array
+        ? value
+        : [value];
+}
+
+exports.coalescing = coalescing;

package/dist/array/coalescing.d.ts

@@ -0,0 +1,3 @@
+import { type AnyValue } from "../common";
+import { type ArrayCoalescing } from "./types";
+export declare function coalescing<GenericValue extends AnyValue>(value: GenericValue): ArrayCoalescing<GenericValue>;

package/dist/array/coalescing.mjs

@@ -0,0 +1,7 @@
+function coalescing(value) {
+    return value instanceof Array
+        ? value
+        : [value];
+}
+
+export { coalescing };

package/dist/array/index.cjs

@@ -49,6 +49,7 @@ var insert$1 = require('./findAndSplice/insert.cjs');
 var replace$1 = require('./findAndSplice/replace.cjs');
 var sum = require('./sum.cjs');
 var length = require('./length.cjs');
+var coalescing = require('./coalescing.cjs');
 
 
 
@@ -103,3 +104,4 @@ exports.findAndSpliceInsert = insert$1.findAndSpliceInsert;
 exports.findAndSpliceReplace = replace$1.findAndSpliceReplace;
 exports.sum = sum.sum;
 exports.length = length.length;
+exports.coalescing = coalescing.coalescing;

package/dist/array/index.d.ts

@@ -39,3 +39,4 @@ export * from "./findAndReplace";
 export * from "./findAndSplice";
 export * from "./sum";
 export * from "./length";
+export * from "./coalescing";

package/dist/array/index.mjs

@@ -47,3 +47,4 @@ export { findAndSpliceInsert } from './findAndSplice/insert.mjs';
 export { findAndSpliceReplace } from './findAndSplice/replace.mjs';
 export { sum } from './sum.mjs';
 export { length } from './length.mjs';
+export { coalescing } from './coalescing.mjs';

package/dist/array/map.cjs

@@ -6,7 +6,7 @@ function map(...args) {
         return (array) => map(array, theFunction);
     }
     const [array, theFunction] = args;
-    return array.map((item, index) => theFunction(item, { index }));
+    return array.map((element, index) => theFunction(element, { index }));
 }
 
 exports.map = map;

package/dist/array/map.d.ts

@@ -1,6 +1,6 @@
 interface ArrayMapParams {
     index: number;
 }
-export declare function map<GenericArray extends readonly unknown[], GenericOutput extends unknown>(theFunction: (item: GenericArray[number], params: ArrayMapParams) => GenericOutput): (array: GenericArray) => GenericOutput[];
-export declare function map<GenericElement extends unknown, GenericOutput extends unknown>(array: readonly GenericElement[], theFunction: (item: GenericElement, params: ArrayMapParams) => GenericOutput): GenericOutput[];
+export declare function map<GenericArray extends readonly unknown[], GenericOutput extends unknown>(theFunction: (element: GenericArray[number], params: ArrayMapParams) => GenericOutput): (array: GenericArray) => GenericOutput[];
+export declare function map<GenericElement extends unknown, GenericOutput extends unknown>(array: readonly GenericElement[], theFunction: (element: GenericElement, params: ArrayMapParams) => GenericOutput): GenericOutput[];
 export {};

package/dist/array/map.mjs

@@ -4,7 +4,7 @@ function map(...args) {
         return (array) => map(array, theFunction);
     }
     const [array, theFunction] = args;
-    return array.map((item, index) => theFunction(item, { index }));
+    return array.map((element, index) => theFunction(element, { index }));
 }
 
 export { map };

package/dist/array/reduce.cjs

@@ -7,7 +7,7 @@ var override = require('../object/override.cjs');
 
 const arrayReduceFromKind = kind.createKind("array-reduce-from");
 function reduceFrom(value) {
-    return arrayReduceFromKind.addTo(wrapValue.wrapValue(value));
+    return arrayReduceFromKind.setTo(wrapValue.wrapValue(value));
 }
 function reduce(...args) {
     if (args.length === 2) {

package/dist/array/reduce.mjs

@@ -5,7 +5,7 @@ import { override } from '../object/override.mjs';
 
 const arrayReduceFromKind = createKind("array-reduce-from");
 function reduceFrom(value) {
-    return arrayReduceFromKind.addTo(wrapValue(value));
+    return arrayReduceFromKind.setTo(wrapValue(value));
 }
 function reduce(...args) {
     if (args.length === 2) {

package/dist/array/types/ArrayCoalescing.d.ts

@@ -0,0 +1 @@
+export type ArrayCoalescing<GenericValue extends unknown> = GenericValue extends readonly any[] ? GenericValue : [GenericValue];

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

@@ -7,3 +7,4 @@ export * from "./mergeUnionTuple";
 export * from "./extractTuple";
 export * from "./excludeTuple";
 export * from "./createTuple";
+export * from "./ArrayCoalescing";

package/dist/common/escapeRegExp.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-function escapeRegExp(text) {
-    return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+function escapeRegExp(input) {
+    return input.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 }
 
 exports.escapeRegExp = escapeRegExp;

package/dist/common/escapeRegExp.d.ts

@@ -1 +1 @@
-export declare function escapeRegExp(text: string): string;
+export declare function escapeRegExp<GenericInput extends string>(input: GenericInput): string;

package/dist/common/escapeRegExp.mjs

@@ -1,5 +1,5 @@
-function escapeRegExp(text) {
-    return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+function escapeRegExp(input) {
+    return input.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 }
 
 export { escapeRegExp };

package/dist/common/index.d.ts

@@ -34,3 +34,5 @@ export * from "./and";
 export * from "./or";
 export * from "./whenElse";
 export * from "./justReturn";
+export * from "./memo";
+export * from "./instanceOf";

package/dist/common/instanceOf.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var coalescing = require('../array/coalescing.cjs');
+
+function instanceOf(...args) {
+    if (args.length === 1) {
+        const [constructor] = args;
+        return (input) => instanceOf(input, constructor);
+    }
+    const [input, constructor] = args;
+    const formattedConstructor = coalescing.coalescing(constructor);
+    for (const constructor of formattedConstructor) {
+        if (input instanceof constructor) {
+            return true;
+        }
+    }
+    return false;
+}
+
+exports.instanceOf = instanceOf;

package/dist/common/instanceOf.d.ts

@@ -0,0 +1,3 @@
+import { type AnyConstructor } from "./types";
+export declare function instanceOf<GenericInput extends unknown, GenericConstructor extends AnyConstructor>(constructor: GenericConstructor | GenericConstructor[]): (input: GenericInput) => input is Extract<GenericInput, InstanceType<GenericConstructor>>;
+export declare function instanceOf<GenericInput extends unknown, GenericConstructor extends AnyConstructor>(input: GenericInput, constructor: GenericConstructor | GenericConstructor[]): input is Extract<GenericInput, InstanceType<GenericConstructor>>;

package/dist/common/instanceOf.mjs

@@ -0,0 +1,18 @@
+import { coalescing } from '../array/coalescing.mjs';
+
+function instanceOf(...args) {
+    if (args.length === 1) {
+        const [constructor] = args;
+        return (input) => instanceOf(input, constructor);
+    }
+    const [input, constructor] = args;
+    const formattedConstructor = coalescing(constructor);
+    for (const constructor of formattedConstructor) {
+        if (input instanceof constructor) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export { instanceOf };

package/dist/common/kind.cjs

@@ -6,7 +6,10 @@ const keyKindPrefix = `${wrapValue.keyWrappedValue}/kind/`;
 function createKind(name) {
     const runTimeKey = `${keyKindPrefix}${name}`;
     return {
-        definition: undefined,
+        definition: {
+            name,
+            value: null,
+        },
         runTimeKey,
         addTo(input, value = null) {
             return {
@@ -14,6 +17,10 @@ function createKind(name) {
                 [runTimeKey]: value,
             };
         },
+        setTo(input, value = null) {
+            input[runTimeKey] = value;
+            return input;
+        },
         has(input) {
             return input
                 && typeof input === "object"
@@ -24,6 +31,43 @@ function createKind(name) {
         },
     };
 }
+function createKindNamespace(namespace) {
+    return (name) => {
+        const kindHandler = createKind(`@${namespace}/${name}`);
+        return kindHandler;
+    };
+}
+function kindHeritage(uniqueName, kind) {
+    const uniqueKind = createKind(uniqueName);
+    const kinds = kind instanceof Array
+        ? kind
+        : [kind];
+    const ParentKindClass = (function ParentKindClass(params = {}) {
+        for (const kind of kinds) {
+            this[kind.runTimeKey] = params[kind.definition.name] ?? null;
+        }
+    });
+    kinds.forEach((value) => {
+        ParentKindClass.prototype[value.runTimeKey] = null;
+    });
+    ParentKindClass.prototype[uniqueKind.runTimeKey] = null;
+    Object.defineProperty(ParentKindClass, Symbol.hasInstance, {
+        value: (value) => {
+            if (!uniqueKind.has(value)) {
+                return false;
+            }
+            for (const kind of kinds) {
+                if (!kind.has(value)) {
+                    return false;
+                }
+            }
+            return true;
+        },
+    });
+    return ParentKindClass;
+}
 
 exports.createKind = createKind;
+exports.createKindNamespace = createKindNamespace;
 exports.keyKindPrefix = keyKindPrefix;
+exports.kindHeritage = kindHeritage;

package/dist/common/kind.d.ts

@@ -1,5 +1,7 @@
-import { type Or, type IsEqual, type BreakGenericLink } from "./types";
-export interface KindHandler<GenericKindDefinition extends KindDefinition> {
+import { type ForbiddenCharacters } from "../string";
+import { type Or, type IsEqual, type BreakGenericLink, type Adaptor, type UnionToIntersection } from "./types";
+import { type GetPropsWithValue, type PartialKeys } from "../object";
+export interface KindHandler<GenericKindDefinition extends KindDefinition = KindDefinition> {
     definition: GenericKindDefinition;
     runTimeKey: string;
     has<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, Kind<GenericKindDefinition, GenericKindDefinition["value"]>>;
@@ -8,6 +10,14 @@ export interface KindHandler<GenericKindDefinition extends KindDefinition> {
         IsEqual<GenericValue, unknown>,
         IsEqual<GenericValue, any>
     ]> extends true ? [input: GenericInput, value?: GenericValue] : [input: GenericInput, value: GenericValue]): Kind<GenericKindDefinition, GenericValue> & BreakGenericLink<GenericInput>;
+    /**
+     * @deprecated This method make mutation.
+     */
+    setTo<GenericInput extends {}, GenericValue extends GenericKindDefinition["value"] = GenericKindDefinition["value"]>(...args: Or<[
+        IsEqual<GenericValue, never>,
+        IsEqual<GenericValue, unknown>,
+        IsEqual<GenericValue, any>
+    ]> extends true ? [input: GenericInput, value?: GenericValue] : [input: GenericInput, value: GenericValue]): Kind<GenericKindDefinition, GenericValue> & BreakGenericLink<GenericInput>;
     getValue<GenericKind extends Kind<GenericKindDefinition, GenericKindDefinition["value"]>>(input: GenericKind): GenericKind[SymbolKind][GenericKindDefinition["name"]];
 }
 export interface KindDefinition<GenericName extends string = string, GenericValue extends unknown = unknown> {
@@ -16,11 +26,21 @@ export interface KindDefinition<GenericName extends string = string, GenericValu
 }
 declare const SymbolKind: unique symbol;
 type SymbolKind = typeof SymbolKind;
-export interface Kind<GenericKindDefinition extends KindDefinition, GenericValue extends KindDefinition["value"] = KindDefinition["value"]> {
+export interface Kind<GenericKindDefinition extends KindDefinition, GenericValue extends GenericKindDefinition["value"] = GenericKindDefinition["value"]> {
     [SymbolKind]: {
         [Prop in GenericKindDefinition["name"]]: GenericValue;
     };
 }
+export type RemoveKind<GenericObject extends Kind<any>> = Omit<GenericObject, SymbolKind>;
+export type GetKindValue<GenericKindHandler extends KindHandler, GenericObject extends Kind<any>> = GenericObject[SymbolKind][GenericKindHandler["definition"]["name"]];
+export type GetKindHandler<GenericObject extends Kind<any>> = {
+    [Prop in keyof GenericObject[SymbolKind]]: KindHandler<KindDefinition<Adaptor<Prop, string>, GenericObject[SymbolKind][Prop]>>;
+}[keyof GenericObject[SymbolKind]];
 export declare const keyKindPrefix = "@duplojs/utils/value/kind/";
-export declare function createKind<GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName): KindHandler<KindDefinition<GenericName, GenericKindValue>>;
+export declare function createKind<GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & ForbiddenCharacters<GenericName, "@" | "/">): KindHandler<KindDefinition<GenericName, GenericKindValue>>;
+export declare function createKindNamespace<GenericNamespace extends string>(namespace: GenericNamespace & ForbiddenCharacters<GenericNamespace, "@" | "/">): <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & ForbiddenCharacters<GenericName, "@" | "/">) => KindHandler<KindDefinition<`@${GenericNamespace}/${GenericName}`, GenericKindValue>>;
+export type KindHeritageConstructorParams<GenericKindHandler extends KindHandler> = {
+    [KindHandler in GenericKindHandler as KindHandler["definition"]["name"]]: KindHandler["definition"]["value"];
+} extends infer InferredResult extends object ? PartialKeys<InferredResult, GetPropsWithValue<InferredResult, unknown>> : never;
+export declare function kindHeritage<GenericUniqueName extends string, GenericKindHandler extends KindHandler>(uniqueName: GenericUniqueName & ForbiddenCharacters<GenericUniqueName, "@" | "/">, kind: GenericKindHandler | GenericKindHandler[]): new (...args: IsEqual<GenericKindHandler extends KindHandler ? IsEqual<GenericKindHandler["definition"]["value"], unknown> : never, true> extends true ? [params?: KindHeritageConstructorParams<GenericKindHandler>] : [params: KindHeritageConstructorParams<GenericKindHandler>]) => UnionToIntersection<(GenericKindHandler extends KindHandler ? Kind<GenericKindHandler["definition"]> : never) | Kind<KindDefinition<GenericUniqueName, unknown>>>;
 export {};

package/dist/common/kind.mjs

@@ -4,7 +4,10 @@ const keyKindPrefix = `${keyWrappedValue}/kind/`;
 function createKind(name) {
     const runTimeKey = `${keyKindPrefix}${name}`;
     return {
-        definition: undefined,
+        definition: {
+            name,
+            value: null,
+        },
         runTimeKey,
         addTo(input, value = null) {
             return {
@@ -12,6 +15,10 @@ function createKind(name) {
                 [runTimeKey]: value,
             };
         },
+        setTo(input, value = null) {
+            input[runTimeKey] = value;
+            return input;
+        },
         has(input) {
             return input
                 && typeof input === "object"
@@ -22,5 +29,40 @@ function createKind(name) {
         },
     };
 }
+function createKindNamespace(namespace) {
+    return (name) => {
+        const kindHandler = createKind(`@${namespace}/${name}`);
+        return kindHandler;
+    };
+}
+function kindHeritage(uniqueName, kind) {
+    const uniqueKind = createKind(uniqueName);
+    const kinds = kind instanceof Array
+        ? kind
+        : [kind];
+    const ParentKindClass = (function ParentKindClass(params = {}) {
+        for (const kind of kinds) {
+            this[kind.runTimeKey] = params[kind.definition.name] ?? null;
+        }
+    });
+    kinds.forEach((value) => {
+        ParentKindClass.prototype[value.runTimeKey] = null;
+    });
+    ParentKindClass.prototype[uniqueKind.runTimeKey] = null;
+    Object.defineProperty(ParentKindClass, Symbol.hasInstance, {
+        value: (value) => {
+            if (!uniqueKind.has(value)) {
+                return false;
+            }
+            for (const kind of kinds) {
+                if (!kind.has(value)) {
+                    return false;
+                }
+            }
+            return true;
+        },
+    });
+    return ParentKindClass;
+}
 
-export { createKind, keyKindPrefix };
+export { createKind, createKindNamespace, keyKindPrefix, kindHeritage };

package/dist/common/memo.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+function memo(theFunction) {
+    const payload = {
+        get value() {
+            const value = theFunction();
+            Object.defineProperty(payload, "value", {
+                value,
+            });
+            return value;
+        },
+    };
+    return payload;
+}
+
+exports.memo = memo;

package/dist/common/memo.d.ts

@@ -0,0 +1,5 @@
+import { type AnyValue } from "./types";
+export interface Memoized<GenericValue extends unknown> {
+    readonly value: GenericValue;
+}
+export declare function memo<GenericOutput extends AnyValue>(theFunction: () => GenericOutput): Memoized<GenericOutput>;

package/dist/common/memo.mjs

@@ -0,0 +1,14 @@
+function memo(theFunction) {
+    const payload = {
+        get value() {
+            const value = theFunction();
+            Object.defineProperty(payload, "value", {
+                value,
+            });
+            return value;
+        },
+    };
+    return payload;
+}
+
+export { memo };

package/dist/common/simpleClone.cjs

@@ -7,8 +7,8 @@ function simpleClone(unknownValue) {
     else if (typeof unknownValue !== "object") {
         return unknownValue;
     }
-    else if (unknownValue.constructor?.name === "Object"
-        || unknownValue.constructor === undefined) {
+    else if (unknownValue.constructor === undefined
+        || unknownValue.constructor.name === "Object") {
         return Object.entries(unknownValue).reduce((pv, [key, value]) => {
             pv[key] = simpleClone(value);
             return pv;

package/dist/common/simpleClone.mjs

@@ -5,8 +5,8 @@ function simpleClone(unknownValue) {
     else if (typeof unknownValue !== "object") {
         return unknownValue;
     }
-    else if (unknownValue.constructor?.name === "Object"
-        || unknownValue.constructor === undefined) {
+    else if (unknownValue.constructor === undefined
+        || unknownValue.constructor.name === "Object") {
         return Object.entries(unknownValue).reduce((pv, [key, value]) => {
             pv[key] = simpleClone(value);
             return pv;

package/dist/common/types/anyConstructor.d.ts

@@ -0,0 +1 @@
+export type AnyConstructor<GenericArgs extends any[] = any[], GenericInstance extends any = any> = new (...args: GenericArgs) => GenericInstance;

package/dist/common/types/anyPredicate.d.ts

@@ -0,0 +1 @@
+export type AnyPredicate<GenericInput extends any = any, GenericArgs extends any[] = any[], GenericPredicate extends GenericInput = any> = (input: GenericInput, ...args: GenericArgs) => input is GenericPredicate;

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

@@ -35,3 +35,5 @@ export * from "./lastUnionElement";
 export * from "./removeDuplicateInUnion";
 export * from "./isStringLIteral";
 export * from "./maybeWrapped";
+export * from "./anyConstructor";
+export * from "./anyPredicate";

package/dist/common/types/objectEntry.d.ts

@@ -1,2 +1,2 @@
 import { type ObjectKey } from "./objectKey";
-export type ObjectEntry = [ObjectKey, any];
+export type ObjectEntry = readonly [ObjectKey, any];

package/dist/common/types/predicate.d.ts

@@ -0,0 +1 @@
+export type Predicate<GenericFunction extends (input: any, ...args: any[]) => input is any> = GenericFunction extends (input: any, ...args: any[]) => input is infer InferredPredicate ? InferredPredicate : never;

package/dist/common/types/unionContain.d.ts

@@ -1,2 +1,2 @@
 import { type IsEqual } from "./isEqual";
-export type UnionContain<GenericUnion extends unknown, GenericValue extends unknown> = IsEqual<GenericUnion extends any ? IsEqual<GenericUnion, GenericValue> : never, boolean>;
+export type UnionContain<GenericUnion extends unknown, GenericValue extends unknown> = IsEqual<(GenericUnion extends any ? IsEqual<GenericUnion, GenericValue> : never) | false, boolean>;

package/dist/dataParser/base.cjs

@@ -0,0 +1,116 @@
+'use strict';
+
+var simpleClone = require('../common/simpleClone.cjs');
+var error = require('./error.cjs');
+var error$1 = require('../either/left/error.cjs');
+var success = require('../either/right/success.cjs');
+var kind = require('./kind.cjs');
+
+const SymbolDataParserErrorLabel = "SymbolDataParserError";
+const SymbolDataParserError = Symbol.for(SymbolDataParserErrorLabel);
+const dataParserCheckerKind = kind.createDataParserKind("checker");
+function dataParserCheckerInit(kind, params, exec) {
+    return kind.setTo(dataParserCheckerKind.setTo({
+        ...params,
+        exec,
+    }));
+}
+const dataParserKind = kind.createDataParserKind("base");
+function dataParserInit(kind, params, exec) {
+    const formattedExec = typeof exec === "object"
+        ? exec
+        : {
+            sync: exec,
+            async: exec,
+        };
+    function middleExec(data, error$1) {
+        let result = formattedExec.sync(data, error$1, dataParser);
+        if (result === error.SymbolDataParserErrorIssue) {
+            error.addIssue(error$1, dataParser, data);
+            return SymbolDataParserError;
+        }
+        else if (result === error.SymbolDataParserErrorPromiseIssue) {
+            error.addPromiseIssue(error$1, dataParser, data);
+            return SymbolDataParserError;
+        }
+        else if (result !== SymbolDataParserError
+            && dataParser.definition.checkers.length) {
+            for (const checker of dataParser.definition.checkers) {
+                const checkerResult = checker.exec(result, checker);
+                if (checkerResult === error.SymbolDataParserErrorIssue) {
+                    error.addIssue(error$1, checker, result);
+                    return SymbolDataParserError;
+                }
+                else {
+                    result = checkerResult;
+                }
+            }
+        }
+        return result;
+    }
+    async function middleAsyncExec(data, error$1) {
+        let result = await formattedExec.async(data, error$1, dataParser);
+        if (result === error.SymbolDataParserErrorIssue) {
+            error.addIssue(error$1, dataParser, data);
+            return SymbolDataParserError;
+        }
+        else if (result === error.SymbolDataParserErrorPromiseIssue) {
+            error.addPromiseIssue(error$1, dataParser, data);
+            return SymbolDataParserError;
+        }
+        else if (result !== SymbolDataParserError
+            && dataParser.definition.checkers.length) {
+            for (const checker of dataParser.definition.checkers) {
+                const checkerResult = checker.exec(result, checker);
+                if (checkerResult === error.SymbolDataParserErrorIssue) {
+                    error.addIssue(error$1, checker, result);
+                    return SymbolDataParserError;
+                }
+                else {
+                    result = checkerResult;
+                }
+            }
+        }
+        return result;
+    }
+    const dataParser = kind.setTo(dataParserKind.setTo({
+        ...params,
+        exec: middleExec,
+        asyncExec: middleAsyncExec,
+        parse(data) {
+            const error$2 = error.createError();
+            const result = middleExec(data, error$2);
+            if (result === SymbolDataParserError) {
+                return error$1.error(error$2);
+            }
+            return success.success(result);
+        },
+        async asyncParse(data) {
+            const error$2 = error.createError();
+            const result = await middleAsyncExec(data, error$2);
+            if (result === SymbolDataParserError) {
+                return error$1.error(error$2);
+            }
+            return success.success(result);
+        },
+        addChecker: (...checkers) => dataParserInit(kind, simpleClone.simpleClone({
+            ...params,
+            definition: {
+                ...params.definition,
+                checkers: [...params.definition.checkers, ...checkers],
+            },
+        }), exec),
+        clone: () => dataParserInit(kind, simpleClone.simpleClone(params), exec),
+    }, {
+        output: undefined,
+        input: undefined,
+    }));
+    return dataParser;
+}
+
+exports.SymbolDataParserError = SymbolDataParserError;
+exports.SymbolDataParserErrorLabel = SymbolDataParserErrorLabel;
+exports.dataParserCheckerInit = dataParserCheckerInit;
+exports.dataParserCheckerKind = dataParserCheckerKind;
+exports.dataParserInit = dataParserInit;
+exports.dataParserKind = dataParserKind;

package/dist/dataParser/base.d.ts

@@ -0,0 +1,44 @@
+import { type AnyValue, type GetKindHandler, type GetKindValue, type Kind, type KindHandler, type RemoveKind } from "../common";
+import { SymbolDataParserErrorIssue, SymbolDataParserErrorPromiseIssue, type DataParserError } from "./error";
+import * as DEither from "../either";
+export declare const SymbolDataParserErrorLabel = "SymbolDataParserError";
+export declare const SymbolDataParserError: unique symbol;
+export type SymbolDataParserError = typeof SymbolDataParserError;
+export declare const dataParserCheckerKind: KindHandler<import("../common").KindDefinition<"@DataParser/checker", unknown>>;
+export interface DataParserCheckerDefinition {
+    readonly errorMessage?: string;
+}
+export interface DataParserChecker<GenericDefinition extends DataParserCheckerDefinition = DataParserCheckerDefinition, GenericInput extends AnyValue = AnyValue> extends Kind<typeof dataParserCheckerKind.definition, GenericInput> {
+    readonly definition: GenericDefinition;
+    exec(data: GenericInput, self: this): GenericInput | SymbolDataParserErrorIssue;
+}
+export declare function dataParserCheckerInit<GenericDataParserChecker extends DataParserChecker>(kind: Exclude<GetKindHandler<GenericDataParserChecker>, typeof dataParserCheckerKind>, params: NoInfer<Omit<RemoveKind<GenericDataParserChecker>, "exec">>, exec: (...args: Parameters<GenericDataParserChecker["exec"]>) => GetKindValue<typeof dataParserCheckerKind, GenericDataParserChecker> | SymbolDataParserErrorIssue): GenericDataParserChecker;
+export declare const dataParserKind: KindHandler<import("../common").KindDefinition<"@DataParser/base", {
+    input: unknown;
+    output: unknown;
+}>>;
+export interface DataParserDefinition<GenericChecker extends DataParserChecker = DataParserChecker> {
+    readonly errorMessage?: string;
+    readonly checkers: readonly GenericChecker[];
+}
+export interface DataParser<GenericDefinition extends DataParserDefinition = DataParserDefinition, GenericOutput extends unknown = unknown, GenericInput extends unknown = GenericOutput> extends Kind<typeof dataParserKind.definition, {
+    input: GenericInput;
+    output: GenericOutput;
+}> {
+    readonly definition: GenericDefinition;
+    exec(data: unknown, error: DataParserError): GenericOutput | SymbolDataParserError;
+    asyncExec(data: unknown, error: DataParserError): Promise<GenericOutput | SymbolDataParserError>;
+    parse(data: unknown): DEither.EitherSuccess<GenericOutput> | DEither.EitherError<DataParserError>;
+    asyncParse(data: unknown): Promise<DEither.EitherSuccess<GenericOutput> | DEither.EitherError<DataParserError>>;
+    addChecker(...args: never): DataParser;
+    clone(): this;
+}
+interface DataParserInitExecParams<GenericDataParser extends DataParser> {
+    sync(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): (GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue);
+    async(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): Promise<GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue>;
+}
+export declare function dataParserInit<GenericDataParser extends DataParser>(kind: Exclude<GetKindHandler<GenericDataParser>, typeof dataParserKind>, params: NoInfer<Omit<RemoveKind<GenericDataParser>, "parse" | "exec" | "asyncParse" | "asyncExec" | "addChecker" | "clone">>, exec: (DataParserInitExecParams<GenericDataParser> | DataParserInitExecParams<GenericDataParser>["sync"])): GenericDataParser;
+export type Output<GenericDataParser extends DataParser> = GetKindValue<typeof dataParserKind, GenericDataParser>["output"];
+export type Input<GenericDataParser extends DataParser> = GetKindValue<typeof dataParserKind, GenericDataParser>["input"];
+export type Contract<GenericOutput extends unknown, GenericInput extends unknown = GenericOutput> = DataParser<DataParserDefinition<never>, GenericOutput, GenericInput>;
+export {};