@duplojs/utils 1.6.1 → 1.6.3

package/dist/common/printer.mjs

@@ -0,0 +1,73 @@
+import { repeat } from '../string/repeat.mjs';
+
+var Printer;
+(function (Printer) {
+    const codeColors = {
+        red: "\x1b[31m",
+        green: "\x1b[32m",
+        yellow: "\x1b[33m",
+        blue: "\x1b[34m",
+        magenta: "\x1b[35m",
+        cyan: "\x1b[36m",
+        gray: "\x1b[90m",
+    };
+    const codeBold = "\x1b[1m";
+    const codeReset = "\x1b[0m";
+    Printer.tab = "\t";
+    Printer.back = "\n";
+    Printer.dash = "-";
+    function colorized(...args) {
+        if (args.length === 1) {
+            const [color] = args;
+            return (input) => colorized(input, color);
+        }
+        const [input, color] = args;
+        return `${codeColors[color]}${input}${codeReset}`;
+    }
+    Printer.colorized = colorized;
+    /**
+     * {@include common/printer/bold/index.md}
+     */
+    function bold(input) {
+        return `${codeBold}${input}${codeReset}`;
+    }
+    Printer.bold = bold;
+    function colorizedBold(...args) {
+        if (args.length === 1) {
+            const [color] = args;
+            return (input) => colorizedBold(input, color);
+        }
+        const [input, color] = args;
+        return bold(colorized(input, color));
+    }
+    Printer.colorizedBold = colorizedBold;
+    function indent(level) {
+        return repeat(Printer.tab, level);
+    }
+    Printer.indent = indent;
+    function stringify(value) {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    Printer.stringify = stringify;
+    function render(...args) {
+        if (args.length === 1) {
+            const [joinCharacter] = args;
+            return (values) => render(values, joinCharacter);
+        }
+        const [values, joinCharacter] = args;
+        return values
+            .flat(Infinity)
+            .filter((value) => typeof value === "string" || value === true)
+            .join(joinCharacter);
+    }
+    Printer.render = render;
+    Printer.renderLine = render(" ");
+    Printer.renderParagraph = render(Printer.back);
+})(Printer || (Printer = {}));
+
+export { Printer };

package/dist/common/queue.cjs

@@ -0,0 +1,90 @@
+'use strict';
+
+var callThen = require('./callThen.cjs');
+var externalPromise = require('./externalPromise.cjs');
+var kind = require('./kind.cjs');
+var create = require('../either/left/create.cjs');
+
+const queueKind = kind.createKind("queue");
+/**
+ * {@include common/queue/index.md}
+ */
+function createQueue(params) {
+    const concurrency = params?.concurrency === undefined || params.concurrency < 1
+        ? 1
+        : params.concurrency;
+    let quantityRunning = 0;
+    let firstElement = undefined;
+    function add(theFunction) {
+        const externalPromise$1 = externalPromise.createExternalPromise();
+        const preparedFunction = () => {
+            quantityRunning++;
+            if (firstElement?.theFunction === preparedFunction) {
+                if (firstElement === firstElement.next) {
+                    firstElement = undefined;
+                }
+                else {
+                    const newFirst = firstElement.next;
+                    const last = firstElement.previous;
+                    newFirst.previous = last;
+                    last.next = newFirst;
+                    firstElement = newFirst;
+                }
+            }
+            let result = undefined;
+            try {
+                const MaybePromise = theFunction();
+                result = MaybePromise instanceof Promise
+                    ? MaybePromise.catch((error) => create.left("execution-error", error))
+                    : MaybePromise;
+            }
+            catch (error) {
+                result = create.left("execution-error", error);
+            }
+            callThen.callThen(result, (output) => {
+                externalPromise$1.resolve(output);
+                quantityRunning--;
+                firstElement?.theFunction();
+            });
+        };
+        if (quantityRunning < concurrency) {
+            void preparedFunction();
+        }
+        else if (firstElement === undefined) {
+            firstElement = {
+                theFunction: preparedFunction,
+                next: undefined,
+                previous: undefined,
+            };
+            firstElement.next = firstElement;
+            firstElement.previous = firstElement;
+        }
+        else {
+            const oldLast = firstElement.previous;
+            const newLastElement = {
+                theFunction: preparedFunction,
+                next: firstElement,
+                previous: firstElement.previous,
+            };
+            oldLast.next = newLastElement;
+            firstElement.previous = newLastElement;
+        }
+        return externalPromise$1.promise;
+    }
+    function addExternal() {
+        const externalPromiseToStart = externalPromise.createExternalPromise();
+        const externalPromiseToFinish = externalPromise.createExternalPromise();
+        void add(() => {
+            externalPromiseToStart.resolve(externalPromiseToFinish.resolve);
+            return externalPromiseToFinish.promise;
+        });
+        return externalPromiseToStart.promise;
+    }
+    return queueKind.setTo({
+        add,
+        addExternal,
+    });
+}
+
+exports.createQueue = createQueue;
+exports.queueKind = queueKind;

package/dist/common/queue.d.ts

@@ -0,0 +1,46 @@
+import { type Kind } from "./kind";
+import * as DEither from "../either";
+export declare const queueKind: import("./kind").KindHandler<import("./kind").KindDefinition<"queue", unknown>>;
+export interface Queue extends Kind<typeof queueKind.definition> {
+    add<GenericOutput extends unknown>(theFunction: () => GenericOutput): Promise<Awaited<GenericOutput> | DEither.Left<"execution-error", unknown>>;
+    addExternal(): Promise<() => void>;
+}
+export interface CreateQueueParams {
+    concurrency?: number;
+}
+/**
+ * The createQueue() function creates a FIFO queue object that limits how many tasks run at the same time and resolves each task result as a promise.
+ * 
+ * Supported call styles:
+ * - Classic: `createQueue()` → returns a queue object
+ * - Classic with options: `createQueue({ concurrency })` → returns a queue object
+ * 
+ * Behavior:
+ * - `queue.add(callback)` starts the callback immediately when a slot is available, otherwise it enqueues it
+ * - task results are always exposed through a promise
+ * - thrown errors and rejected promises are converted to `DEither.left("execution-error", error)`
+ * - `queue.addExternal()` reserves one slot and resolves with a release function
+ * 
+ * ```ts
+ * const defaultQueue = createQueue();
+ * const numberResult = await defaultQueue.add(() => 42);
+ * // type: 42 | Left<"execution-error", unknown>
+ * 
+ * const serialQueue = createQueue({
+ * 	concurrency: 1,
+ * });
+ * const textResult = await serialQueue.add(() => "hello" as const);
+ * // type: "hello" | Left<"execution-error", unknown>
+ * 
+ * const asyncQueue = createQueue();
+ * const asyncResult = await asyncQueue.add(
+ * 	async() => Promise.resolve("done" as const),
+ * );
+ * // type: "done" | Left<"execution-error", unknown>
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/queue
+ * 
+ */
+export declare function createQueue(params?: CreateQueueParams): Queue;

package/dist/common/queue.mjs

@@ -0,0 +1,87 @@
+import { callThen } from './callThen.mjs';
+import { createExternalPromise } from './externalPromise.mjs';
+import { createKind } from './kind.mjs';
+import { left } from '../either/left/create.mjs';
+
+const queueKind = createKind("queue");
+/**
+ * {@include common/queue/index.md}
+ */
+function createQueue(params) {
+    const concurrency = params?.concurrency === undefined || params.concurrency < 1
+        ? 1
+        : params.concurrency;
+    let quantityRunning = 0;
+    let firstElement = undefined;
+    function add(theFunction) {
+        const externalPromise = createExternalPromise();
+        const preparedFunction = () => {
+            quantityRunning++;
+            if (firstElement?.theFunction === preparedFunction) {
+                if (firstElement === firstElement.next) {
+                    firstElement = undefined;
+                }
+                else {
+                    const newFirst = firstElement.next;
+                    const last = firstElement.previous;
+                    newFirst.previous = last;
+                    last.next = newFirst;
+                    firstElement = newFirst;
+                }
+            }
+            let result = undefined;
+            try {
+                const MaybePromise = theFunction();
+                result = MaybePromise instanceof Promise
+                    ? MaybePromise.catch((error) => left("execution-error", error))
+                    : MaybePromise;
+            }
+            catch (error) {
+                result = left("execution-error", error);
+            }
+            callThen(result, (output) => {
+                externalPromise.resolve(output);
+                quantityRunning--;
+                firstElement?.theFunction();
+            });
+        };
+        if (quantityRunning < concurrency) {
+            void preparedFunction();
+        }
+        else if (firstElement === undefined) {
+            firstElement = {
+                theFunction: preparedFunction,
+                next: undefined,
+                previous: undefined,
+            };
+            firstElement.next = firstElement;
+            firstElement.previous = firstElement;
+        }
+        else {
+            const oldLast = firstElement.previous;
+            const newLastElement = {
+                theFunction: preparedFunction,
+                next: firstElement,
+                previous: firstElement.previous,
+            };
+            oldLast.next = newLastElement;
+            firstElement.previous = newLastElement;
+        }
+        return externalPromise.promise;
+    }
+    function addExternal() {
+        const externalPromiseToStart = createExternalPromise();
+        const externalPromiseToFinish = createExternalPromise();
+        void add(() => {
+            externalPromiseToStart.resolve(externalPromiseToFinish.resolve);
+            return externalPromiseToFinish.promise;
+        });
+        return externalPromiseToStart.promise;
+    }
+    return queueKind.setTo({
+        add,
+        addExternal,
+    });
+}
+
+export { createQueue, queueKind };

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

@@ -1,2 +1 @@
-import { type IsEqual } from "./isEqual";
-export type And<GenericBooleans extends [boolean, ...boolean[]]> = IsEqual<GenericBooleans[number], true>;
+export type And<GenericBooleans extends [boolean, ...boolean[]]> = GenericBooleans[number] extends true ? true : false;

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

@@ -1,2 +1 @@
-import { type IsEqual } from "./isEqual";
-export type Or<GenericBooleans extends [boolean, ...boolean[]]> = IsEqual<GenericBooleans[number] | false, boolean>;
+export type Or<GenericBooleans extends [boolean, ...boolean[]]> = GenericBooleans[number] extends false ? false : true;

package/dist/dataParser/base.cjs

@@ -11,8 +11,6 @@ var errorKindNamespace = require('../common/errorKindNamespace.cjs');
 var error$1 = require('../either/left/error.cjs');
 var success = require('../either/right/success.cjs');
 
-const SymbolDataParserErrorLabel = "SymbolDataParserError";
-const SymbolDataParserError = Symbol.for(SymbolDataParserErrorLabel);
 const checkerKind = kind.createDataParserKind("checker");
 function dataParserCheckerInit(kind, params, exec) {
     return kind.setTo(checkerKind.setTo({
@@ -22,9 +20,7 @@ function dataParserCheckerInit(kind, params, exec) {
 }
 const dataParserKind = kind.createDataParserKind("base");
 // This allows for better performance WTF ???
-const SDPEI = error.SymbolDataParserErrorIssue;
-const SDPEPI = error.SymbolDataParserErrorPromiseIssue;
-const SDPE = SymbolDataParserError;
+const SDPE = error.SymbolDataParserError;
 const DPE = error.createError();
 const EE = error$1.error(null);
 const ES = success.success(null);
@@ -44,22 +40,13 @@ function dataParserInit(kind, definition, exec, specificOverrideHandler) {
             async: exec,
             isAsynchronous: () => false,
         };
-    function middleExec(data, error$1) {
-        let result = formattedExec.sync(data, error$1, self);
-        if (result === SDPEI) {
-            error.addIssue(error$1, self, data);
-            return SDPE;
-        }
-        else if (result === SDPEPI) {
-            error.addPromiseIssue(error$1, self, data);
-            return SDPE;
-        }
-        else if (result !== SDPE
+    function middleExec(data, error) {
+        let result = formattedExec.sync(data, error, self);
+        if (result !== SDPE
             && self.definition.checkers.length) {
             for (const checker of self.definition.checkers) {
-                const checkerResult = checker.exec(result, checker);
-                if (checkerResult === SDPEI) {
-                    error.addIssue(error$1, checker, result);
+                const checkerResult = checker.exec(result, error, checker);
+                if (checkerResult === SDPE) {
                     return SDPE;
                 }
                 else {
@@ -69,22 +56,13 @@ function dataParserInit(kind, definition, exec, specificOverrideHandler) {
         }
         return result;
     }
-    async function middleAsyncExec(data, error$1) {
-        let result = await formattedExec.async(data, error$1, self);
-        if (result === SDPEI) {
-            error.addIssue(error$1, self, data);
-            return SDPE;
-        }
-        else if (result === SDPEPI) {
-            error.addPromiseIssue(error$1, self, data);
-            return SDPE;
-        }
-        else if (result !== SDPE
+    async function middleAsyncExec(data, error) {
+        let result = await formattedExec.async(data, error, self);
+        if (result !== SDPE
             && self.definition.checkers.length) {
             for (const checker of self.definition.checkers) {
-                const checkerResult = checker.exec(result, checker);
-                if (checkerResult === SDPEI) {
-                    error.addIssue(error$1, checker, result);
+                const checkerResult = checker.exec(result, error, checker);
+                if (checkerResult === SDPE) {
                     return SDPE;
                 }
                 else {
@@ -172,9 +150,8 @@ function dataParserInit(kind, definition, exec, specificOverrideHandler) {
 }
 dataParserInit.overrideHandler = override.createOverride("@duplojs/utils/data-parser/base");
 
+exports.SymbolDataParserError = error.SymbolDataParserError;
 exports.DataParserThrowError = DataParserThrowError;
-exports.SymbolDataParserError = SymbolDataParserError;
-exports.SymbolDataParserErrorLabel = SymbolDataParserErrorLabel;
 exports.checkerKind = checkerKind;
 exports.dataParserCheckerInit = dataParserCheckerInit;
 exports.dataParserInit = dataParserInit;

package/dist/dataParser/base.d.ts

@@ -1,19 +1,17 @@
 import { type GetKind, type GetKindHandler, type GetKindValue, type IsEqual, type Kind, type KindHandler, type OverrideHandler, type RemoveKind } from "../common";
-import { SymbolDataParserErrorIssue, SymbolDataParserErrorPromiseIssue, type DataParserError } from "./error";
+import { SymbolDataParserError, 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 { SymbolDataParserError } from "./error";
 export declare const checkerKind: KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/checker", unknown>>;
 export interface DataParserCheckerDefinition {
     readonly errorMessage?: string;
 }
 export interface DataParserChecker<GenericDefinition extends DataParserCheckerDefinition = DataParserCheckerDefinition, GenericInput extends unknown = unknown> extends Kind<typeof checkerKind.definition, GenericInput> {
     readonly definition: GenericDefinition;
-    exec(data: GenericInput, self: this): GenericInput | SymbolDataParserErrorIssue;
+    exec(data: GenericInput, error: DataParserError, self: this): GenericInput | SymbolDataParserError;
 }
 export type InputChecker<GenericDataParser extends DataParserChecker> = Parameters<GenericDataParser["exec"]>[0];
-export declare function dataParserCheckerInit<GenericDataParserChecker extends DataParserChecker>(kind: Exclude<GetKindHandler<GenericDataParserChecker>, typeof checkerKind>, params: NoInfer<Omit<RemoveKind<GenericDataParserChecker>, "exec">>, exec: (...args: Parameters<GenericDataParserChecker["exec"]>) => GetKindValue<typeof checkerKind, GenericDataParserChecker> | SymbolDataParserErrorIssue): GenericDataParserChecker;
+export declare function dataParserCheckerInit<GenericDataParserChecker extends DataParserChecker>(kind: Exclude<GetKindHandler<GenericDataParserChecker>, typeof checkerKind>, params: NoInfer<Omit<RemoveKind<GenericDataParserChecker>, "exec">>, exec: (...args: Parameters<GenericDataParserChecker["exec"]>) => GetKindValue<typeof checkerKind, GenericDataParserChecker> | SymbolDataParserError): GenericDataParserChecker;
 export declare const dataParserKind: KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
     input: unknown;
     output: unknown;
@@ -239,8 +237,8 @@ export interface DataParser<GenericDefinition extends DataParserDefinition = Dat
     isAsynchronous(): boolean;
 }
 interface DataParserInitExecParams<GenericDataParser extends DataParser> {
-    sync(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): (GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserError | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue);
-    async(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): Promise<GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserError | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue>;
+    sync(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): (GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserError);
+    async(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): Promise<GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserError>;
     isAsynchronous(self: GenericDataParser): boolean;
 }
 declare const DataParserThrowError_base: new (params: {
@@ -261,4 +259,3 @@ export type AdvancedContract<GenericDataParser extends DataParser> = (GetKind<Ge
     addChecker(...args: never): AdvancedContract<GenericDataParser>;
     clone(): AdvancedContract<GenericDataParser>;
 });
-export {};

package/dist/dataParser/base.mjs

@@ -1,4 +1,4 @@
-import { createError, addIssue, addPromiseIssue, SymbolDataParserErrorIssue, SymbolDataParserErrorPromiseIssue } from './error.mjs';
+import { createError, SymbolDataParserError } from './error.mjs';
 import { createDataParserKind } from './kind.mjs';
 import { simpleClone } from '../common/simpleClone.mjs';
 import { keyWrappedValue } from '../common/wrapValue.mjs';
@@ -9,8 +9,6 @@ import { createErrorKind } from '../common/errorKindNamespace.mjs';
 import { error } from '../either/left/error.mjs';
 import { success } from '../either/right/success.mjs';
 
-const SymbolDataParserErrorLabel = "SymbolDataParserError";
-const SymbolDataParserError = Symbol.for(SymbolDataParserErrorLabel);
 const checkerKind = createDataParserKind("checker");
 function dataParserCheckerInit(kind, params, exec) {
     return kind.setTo(checkerKind.setTo({
@@ -20,8 +18,6 @@ function dataParserCheckerInit(kind, params, exec) {
 }
 const dataParserKind = createDataParserKind("base");
 // This allows for better performance WTF ???
-const SDPEI = SymbolDataParserErrorIssue;
-const SDPEPI = SymbolDataParserErrorPromiseIssue;
 const SDPE = SymbolDataParserError;
 const DPE = createError();
 const EE = error(null);
@@ -44,20 +40,11 @@ function dataParserInit(kind, definition, exec, specificOverrideHandler) {
         };
     function middleExec(data, error) {
         let result = formattedExec.sync(data, error, self);
-        if (result === SDPEI) {
-            addIssue(error, self, data);
-            return SDPE;
-        }
-        else if (result === SDPEPI) {
-            addPromiseIssue(error, self, data);
-            return SDPE;
-        }
-        else if (result !== SDPE
+        if (result !== SDPE
             && self.definition.checkers.length) {
             for (const checker of self.definition.checkers) {
-                const checkerResult = checker.exec(result, checker);
-                if (checkerResult === SDPEI) {
-                    addIssue(error, checker, result);
+                const checkerResult = checker.exec(result, error, checker);
+                if (checkerResult === SDPE) {
                     return SDPE;
                 }
                 else {
@@ -69,20 +56,11 @@ function dataParserInit(kind, definition, exec, specificOverrideHandler) {
     }
     async function middleAsyncExec(data, error) {
         let result = await formattedExec.async(data, error, self);
-        if (result === SDPEI) {
-            addIssue(error, self, data);
-            return SDPE;
-        }
-        else if (result === SDPEPI) {
-            addPromiseIssue(error, self, data);
-            return SDPE;
-        }
-        else if (result !== SDPE
+        if (result !== SDPE
             && self.definition.checkers.length) {
             for (const checker of self.definition.checkers) {
-                const checkerResult = checker.exec(result, checker);
-                if (checkerResult === SDPEI) {
-                    addIssue(error, checker, result);
+                const checkerResult = checker.exec(result, error, checker);
+                if (checkerResult === SDPE) {
                     return SDPE;
                 }
                 else {
@@ -170,4 +148,4 @@ function dataParserInit(kind, definition, exec, specificOverrideHandler) {
 }
 dataParserInit.overrideHandler = createOverride("@duplojs/utils/data-parser/base");
 
-export { DataParserThrowError, SymbolDataParserError, SymbolDataParserErrorLabel, checkerKind, dataParserCheckerInit, dataParserInit, dataParserKind };
+export { DataParserThrowError, SymbolDataParserError, checkerKind, dataParserCheckerInit, dataParserInit, dataParserKind };

package/dist/dataParser/error.cjs

@@ -1,13 +1,20 @@
 'use strict';
 
 var kind = require('./kind.cjs');
+var printer = require('../common/printer.cjs');
+var unwrap = require('../common/unwrap.cjs');
 
-const SymbolDataParserErrorIssueLabel = "SymbolDataParserErrorIssue";
+const SymbolDataParserErrorLabel = "SymbolDataParserError";
+const SymbolDataParserError = Symbol.for(SymbolDataParserErrorLabel);
+/**
+ * @deprecated
+ */
+const SymbolDataParserErrorIssueLabel = "SymbolDataParserError";
+/**
+ * @deprecated
+ */
 const SymbolDataParserErrorIssue = Symbol.for(SymbolDataParserErrorIssueLabel);
 const errorIssueKind = kind.createDataParserKind("error-issue");
-const SymbolDataParserErrorPromiseIssueLabel = "SymbolDataParserErrorPromiseIssue";
-const SymbolDataParserErrorPromiseIssue = Symbol.for(SymbolDataParserErrorPromiseIssueLabel);
-const errorPromiseIssueKind = kind.createDataParserKind("error-issue-promise");
 const errorKind = kind.createDataParserKind("error");
 function createError() {
     return errorKind.setTo({
@@ -15,23 +22,14 @@ function createError() {
         currentPath: [],
     });
 }
-function addIssue(error, source, data, moreInformation) {
+function addIssue(error, expected, data, message) {
     error.issues.push(errorIssueKind.setTo({
-        source,
+        expected,
         path: error.currentPath.join("."),
         data,
-        moreInformation,
+        message,
     }));
-    return error;
-}
-function addPromiseIssue(error, source, data, moreInformation) {
-    error.issues.push(errorPromiseIssueKind.setTo({
-        source,
-        path: error.currentPath.join("."),
-        data,
-        moreInformation,
-    }));
-    return error;
+    return SymbolDataParserError;
 }
 function setErrorPath(error, value, index) {
     error.currentPath[index] = value;
@@ -41,16 +39,36 @@ function popErrorPath(error) {
     error.currentPath.pop();
     return error;
 }
+function interpretError(error) {
+    const dataParserError = errorKind.has(error)
+        ? error
+        : unwrap.unwrap(error);
+    return printer.Printer.renderParagraph([
+        printer.Printer.colorizedBold("Validation failed", "red"),
+        dataParserError.issues.map((issue) => printer.Printer.renderParagraph([
+            "",
+            printer.Printer.renderLine([
+                printer.Printer.colorizedBold("✖", "red"),
+                printer.Printer.colorizedBold(issue.path || "<root>", "cyan"),
+                "expected",
+                printer.Printer.colorized(issue.expected, "green"),
+                "but received",
+                printer.Printer.colorized(printer.Printer.stringify(issue.data), "red"),
+            ]),
+            issue.message !== undefined && `${printer.Printer.indent(1)}↳ ${issue.message}`,
+        ])),
+        dataParserError.issues.length === 0 && "No issue found",
+    ]);
+}
 
+exports.SymbolDataParserError = SymbolDataParserError;
 exports.SymbolDataParserErrorIssue = SymbolDataParserErrorIssue;
 exports.SymbolDataParserErrorIssueLabel = SymbolDataParserErrorIssueLabel;
-exports.SymbolDataParserErrorPromiseIssue = SymbolDataParserErrorPromiseIssue;
-exports.SymbolDataParserErrorPromiseIssueLabel = SymbolDataParserErrorPromiseIssueLabel;
+exports.SymbolDataParserErrorLabel = SymbolDataParserErrorLabel;
 exports.addIssue = addIssue;
-exports.addPromiseIssue = addPromiseIssue;
 exports.createError = createError;
 exports.errorIssueKind = errorIssueKind;
 exports.errorKind = errorKind;
-exports.errorPromiseIssueKind = errorPromiseIssueKind;
+exports.interpretError = interpretError;
 exports.popErrorPath = popErrorPath;
 exports.setErrorPath = setErrorPath;

package/dist/dataParser/error.d.ts

@@ -1,34 +1,34 @@
 import { type Kind } from "../common";
-import { type DataParserTransform } from "./parsers";
-import { type DataParser } from "./base";
-import { type DataParserCheckers } from "./types";
-export declare const SymbolDataParserErrorIssueLabel = "SymbolDataParserErrorIssue";
+import type * as DEither from "../either";
+export declare const SymbolDataParserErrorLabel = "SymbolDataParserError";
+export declare const SymbolDataParserError: unique symbol;
+export type SymbolDataParserError = typeof SymbolDataParserError;
+/**
+ * @deprecated
+ */
+export declare const SymbolDataParserErrorIssueLabel = "SymbolDataParserError";
+/**
+ * @deprecated
+ */
 export declare const SymbolDataParserErrorIssue: unique symbol;
+/**
+ * @deprecated
+ */
 export type SymbolDataParserErrorIssue = typeof SymbolDataParserErrorIssue;
 export declare const errorIssueKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/error-issue", unknown>>;
 export interface DataParserErrorIssue extends Kind<typeof errorIssueKind.definition> {
-    readonly source: DataParser | DataParserCheckers;
+    readonly expected: string;
     readonly path: string;
     readonly data: unknown;
-    readonly moreInformation?: string;
-}
-export declare const SymbolDataParserErrorPromiseIssueLabel = "SymbolDataParserErrorPromiseIssue";
-export declare const SymbolDataParserErrorPromiseIssue: unique symbol;
-export type SymbolDataParserErrorPromiseIssue = typeof SymbolDataParserErrorPromiseIssue;
-export declare const errorPromiseIssueKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/error-issue-promise", unknown>>;
-export interface DataParserErrorPromiseIssue extends Kind<typeof errorPromiseIssueKind.definition> {
-    readonly source: DataParserTransform;
-    readonly path: string;
-    readonly data: unknown;
-    readonly moreInformation?: string;
+    readonly message: string | undefined;
 }
 export declare const errorKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/error", unknown>>;
 export interface DataParserError extends Kind<typeof errorKind.definition> {
-    readonly issues: (DataParserErrorIssue | DataParserErrorPromiseIssue)[];
+    readonly issues: DataParserErrorIssue[];
     readonly currentPath: string[];
 }
 export declare function createError(): DataParserError;
-export declare function addIssue(error: DataParserError, source: DataParser | DataParserCheckers, data: unknown, moreInformation?: string): DataParserError;
-export declare function addPromiseIssue(error: DataParserError, source: DataParserTransform, data: unknown, moreInformation?: string): DataParserError;
+export declare function addIssue(error: DataParserError, expected: string, data: unknown, message: string | undefined): SymbolDataParserError;
 export declare function setErrorPath(error: DataParserError, value: string, index: number): DataParserError;
 export declare function popErrorPath(error: DataParserError): DataParserError;
+export declare function interpretError(error: DataParserError | DEither.Left<string, DataParserError>): string;