@duplojs/lang 0.0.0 → 0.0.1-beta.10

package/dist/dataStructure/common/error/defaultInterpreter.cjs

@@ -0,0 +1,84 @@
+const require_coalescing = require("../../../array/coalescing.cjs");
+const require_join = require("../../../string/join.cjs");
+const require_stringify = require("../../../string/stringify.cjs");
+const require_to = require("../../../string/to.cjs");
+const require_json = require("../codec/defaults/json.cjs");
+const require_string = require("../codec/defaults/string.cjs");
+const require_base = require("./base.cjs");
+//#region scripts/dataStructure/common/error/defaultInterpreter.ts
+const defaultErrorInterpreterDataStructureDictionary = {
+	"array-structure": () => "Expected an array.",
+	"lazy-structure": () => "Expected a value matching the resolved structure.",
+	"non-encodable-string-structure": (source) => `Expected ${require_stringify.stringify(source.definition.value)}.`,
+	"object-structure": () => "Expected a plain object containing only the defined properties.",
+	"record-structure": () => "Expected a plain object matching the record definition.",
+	"type-structure": () => "Expected a value matching the configured type.",
+	"union-structure": () => "Expected a value matching at least one union member.",
+	"bigint-type": () => "Expected a bigint.",
+	"bigint-literal-type": (source) => `Expected ${require_to.to(source.definition.value)}n.`,
+	"boolean-type": () => "Expected a boolean.",
+	"boolean-literal-type": (source) => `Expected ${source.definition.value}.`,
+	"date-type": () => "Expected a DuploJS date.",
+	"null-type": () => "Expected null.",
+	"number-type": () => "Expected a finite number.",
+	"number-literal-type": (source) => `Expected ${source.definition.value}.`,
+	"string-type": () => "Expected a string.",
+	"string-literal-type": (source) => `Expected ${require_stringify.stringify(source.definition.value)}.`,
+	"time-type": () => "Expected a DuploJS time.",
+	"undefined-type": () => "Expected undefined.",
+	"absolute-path-constraint": () => "Expected an absolute path.",
+	"allowed-characters-constraint": (source) => `Expected a string containing only characters from ${require_join.join(require_coalescing.coalescing(source.definition.charactersRange), ", ")}.`,
+	"array-length-equal-constraint": (source) => `Expected an array containing exactly ${source.definition.length} elements.`,
+	"between-than-constraint": (source) => `Expected a number greater than ${source.definition.greater} and less than ${source.definition.less}.`,
+	"between-than-or-equal-constraint": (source) => `Expected a number greater than or equal to ${source.definition.greater} and less than or equal to ${source.definition.less}.`,
+	"email-constraint": () => "Expected a valid email address.",
+	"even-constraint": () => "Expected an even number.",
+	"greater-than-constraint": (source) => `Expected a number greater than ${source.definition.threshold}.`,
+	"greater-than-or-equal-constraint": (source) => `Expected a number greater than or equal to ${source.definition.threshold}.`,
+	"integer-constraint": () => "Expected an integer.",
+	"less-than-constraint": (source) => `Expected a number less than ${source.definition.threshold}.`,
+	"less-than-or-equal-constraint": (source) => `Expected a number less than or equal to ${source.definition.threshold}.`,
+	"max-characters-constraint": (source) => `Expected a string containing at most ${source.definition.max} characters.`,
+	"max-elements-constraint": (source) => `Expected an array containing at most ${source.definition.max} elements.`,
+	"min-characters-constraint": (source) => `Expected a string containing at least ${source.definition.min} characters.`,
+	"min-elements-constraint": (source) => `Expected an array containing at least ${source.definition.min} elements.`,
+	"multiple-of-constraint": (source) => `Expected a multiple of ${source.definition.multiple}.`,
+	"negative-constraint": () => "Expected a number less than or equal to zero.",
+	"not-empty-constraint": () => "Expected a non-empty string.",
+	"not-zero-constraint": () => "Expected a non-zero number.",
+	"number-in-string-constraint": () => "Expected a string representing a number.",
+	"odd-constraint": () => "Expected an odd number.",
+	"path-constraint": () => "Expected a valid path.",
+	"positive-constraint": () => "Expected a number greater than or equal to zero.",
+	"refine-constraint": () => "Expected a value satisfying the custom refinement.",
+	"regex-constraint": (source) => `Expected a string matching ${source.definition.regex.toString()}.`,
+	"safe-constraint": () => "Expected a number strictly between Number.MIN_SAFE_INTEGER and Number.MAX_SAFE_INTEGER.",
+	"segment-path-constraint": () => "Expected a valid path segment.",
+	"strict-negative-constraint": () => "Expected a number less than zero.",
+	"strict-positive-constraint": () => "Expected a number greater than zero.",
+	"string-length-equal-constraint": (source) => `Expected a string containing exactly ${source.definition.length} characters.`,
+	"trimmed-constraint": () => "Expected a string without leading or trailing whitespace.",
+	"url-constraint": () => "Expected a valid URL.",
+	"uuid-constraint": () => "Expected a valid UUID."
+};
+const createDefaultCodecErrorMessage = (codecName, encodedValueDescription, decodedValueDescription) => (_codec, issue) => {
+	if (issue.from === "predicate") return require_base.encodeIssueKind.has(issue) ? `The ${codecName} codec must produce ${encodedValueDescription}.` : `Expected ${encodedValueDescription} for the ${codecName} codec.`;
+	if (issue.from === "encoding") return `The ${codecName} codec could not encode ${decodedValueDescription}.`;
+	if (issue.from === "decoding") return `The ${codecName} codec could not decode the value as ${decodedValueDescription}.`;
+	return `The ${codecName} codec encountered an external error while ${require_base.encodeIssueKind.has(issue) ? "encoding" : "decoding"}.`;
+};
+const defaultErrorInterpreterCodecDictionary = [
+	[require_json.codecsJson.definition.bigint, createDefaultCodecErrorMessage("JSON bigint", "a string", "a bigint")],
+	[require_json.codecsJson.definition.date, createDefaultCodecErrorMessage("JSON date", "a string", "a DuploJS date")],
+	[require_json.codecsJson.definition.time, createDefaultCodecErrorMessage("JSON time", "a string", "a DuploJS time")],
+	[require_string.codecsString.definition.bigint, createDefaultCodecErrorMessage("string bigint", "a string", "a bigint")],
+	[require_string.codecsString.definition.boolean, createDefaultCodecErrorMessage("string boolean", "the string \"true\" or \"false\"", "a boolean")],
+	[require_string.codecsString.definition.date, createDefaultCodecErrorMessage("string date", "a string", "a DuploJS date")],
+	[require_string.codecsString.definition.null, createDefaultCodecErrorMessage("string null", "the string \"null\"", "null")],
+	[require_string.codecsString.definition.number, createDefaultCodecErrorMessage("string number", "a string representing a number", "a finite number")],
+	[require_string.codecsString.definition.time, createDefaultCodecErrorMessage("string time", "a string", "a DuploJS time")],
+	[require_string.codecsString.definition.undefined, createDefaultCodecErrorMessage("string undefined", "the string \"undefined\"", "undefined")]
+];
+//#endregion
+exports.defaultErrorInterpreterCodecDictionary = defaultErrorInterpreterCodecDictionary;
+exports.defaultErrorInterpreterDataStructureDictionary = defaultErrorInterpreterDataStructureDictionary;

package/dist/dataStructure/common/error/defaultInterpreter.d.ts

@@ -0,0 +1,57 @@
+import * as DString from '../../../string';
+export declare const defaultErrorInterpreterDataStructureDictionary: {
+    readonly "array-structure": () => string;
+    readonly "lazy-structure": () => string;
+    readonly "non-encodable-string-structure": (source: import('../..').NonEncodableStringStructure) => string;
+    readonly "object-structure": () => string;
+    readonly "record-structure": () => string;
+    readonly "type-structure": () => string;
+    readonly "union-structure": () => string;
+    readonly "bigint-type": () => string;
+    readonly "bigint-literal-type": (source: import('../..').BigintLiteralType<bigint>) => string;
+    readonly "boolean-type": () => string;
+    readonly "boolean-literal-type": (source: import('../..').BooleanLiteralType<boolean>) => string;
+    readonly "date-type": () => string;
+    readonly "null-type": () => string;
+    readonly "number-type": () => string;
+    readonly "number-literal-type": (source: import('../..').NumberLiteralType<number>) => string;
+    readonly "string-type": () => string;
+    readonly "string-literal-type": (source: import('../..').StringLiteralType<string>) => string;
+    readonly "time-type": () => string;
+    readonly "undefined-type": () => string;
+    readonly "absolute-path-constraint": () => string;
+    readonly "allowed-characters-constraint": (source: import('../..').AllowedCharactersConstraint<DString.CharactersRange>) => string;
+    readonly "array-length-equal-constraint": (source: import('../..').ArrayLengthEqualConstraint<number>) => string;
+    readonly "between-than-constraint": (source: import('../..').BetweenThanConstraint<number, number>) => string;
+    readonly "between-than-or-equal-constraint": (source: import('../..').BetweenThanOrEqualConstraint<number, number>) => string;
+    readonly "email-constraint": () => string;
+    readonly "even-constraint": () => string;
+    readonly "greater-than-constraint": (source: import('../..').GreaterThanConstraint<number>) => string;
+    readonly "greater-than-or-equal-constraint": (source: import('../..').GreaterThanOrEqualConstraint<number>) => string;
+    readonly "integer-constraint": () => string;
+    readonly "less-than-constraint": (source: import('../..').LessThanConstraint<number>) => string;
+    readonly "less-than-or-equal-constraint": (source: import('../..').LessThanOrEqualConstraint<number>) => string;
+    readonly "max-characters-constraint": (source: import('../..').MaxCharactersConstraint<number>) => string;
+    readonly "max-elements-constraint": (source: import('../..').MaxElementsConstraint<number>) => string;
+    readonly "min-characters-constraint": (source: import('../..').MinCharactersConstraint<number>) => string;
+    readonly "min-elements-constraint": (source: import('../..').MinElementsConstraint<number>) => string;
+    readonly "multiple-of-constraint": (source: import('../..').MultipleOfConstraint<number>) => string;
+    readonly "negative-constraint": () => string;
+    readonly "not-empty-constraint": () => string;
+    readonly "not-zero-constraint": () => string;
+    readonly "number-in-string-constraint": () => string;
+    readonly "odd-constraint": () => string;
+    readonly "path-constraint": () => string;
+    readonly "positive-constraint": () => string;
+    readonly "refine-constraint": () => string;
+    readonly "regex-constraint": (source: import('../..').RegexConstraint) => string;
+    readonly "safe-constraint": () => string;
+    readonly "segment-path-constraint": () => string;
+    readonly "strict-negative-constraint": () => string;
+    readonly "strict-positive-constraint": () => string;
+    readonly "string-length-equal-constraint": (source: import('../..').StringLengthEqualConstraint<number>) => string;
+    readonly "trimmed-constraint": () => string;
+    readonly "url-constraint": () => string;
+    readonly "uuid-constraint": () => string;
+};
+export declare const defaultErrorInterpreterCodecDictionary: [[import('../..').Codec<import('../..').TheBigint, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheDate, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheTime, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheBigint, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheBoolean, "true" | "false">, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheDate, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheNull, "null">, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheNumber, string & DString.Number>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheTime, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheUndefined, "undefined">, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string]];

package/dist/dataStructure/common/error/defaultInterpreter.mjs

@@ -0,0 +1,83 @@
+import { coalescing } from "../../../array/coalescing.mjs";
+import { join } from "../../../string/join.mjs";
+import { stringify } from "../../../string/stringify.mjs";
+import { to } from "../../../string/to.mjs";
+import { codecsJson } from "../codec/defaults/json.mjs";
+import { codecsString } from "../codec/defaults/string.mjs";
+import { encodeIssueKind } from "./base.mjs";
+//#region scripts/dataStructure/common/error/defaultInterpreter.ts
+const defaultErrorInterpreterDataStructureDictionary = {
+	"array-structure": () => "Expected an array.",
+	"lazy-structure": () => "Expected a value matching the resolved structure.",
+	"non-encodable-string-structure": (source) => `Expected ${stringify(source.definition.value)}.`,
+	"object-structure": () => "Expected a plain object containing only the defined properties.",
+	"record-structure": () => "Expected a plain object matching the record definition.",
+	"type-structure": () => "Expected a value matching the configured type.",
+	"union-structure": () => "Expected a value matching at least one union member.",
+	"bigint-type": () => "Expected a bigint.",
+	"bigint-literal-type": (source) => `Expected ${to(source.definition.value)}n.`,
+	"boolean-type": () => "Expected a boolean.",
+	"boolean-literal-type": (source) => `Expected ${source.definition.value}.`,
+	"date-type": () => "Expected a DuploJS date.",
+	"null-type": () => "Expected null.",
+	"number-type": () => "Expected a finite number.",
+	"number-literal-type": (source) => `Expected ${source.definition.value}.`,
+	"string-type": () => "Expected a string.",
+	"string-literal-type": (source) => `Expected ${stringify(source.definition.value)}.`,
+	"time-type": () => "Expected a DuploJS time.",
+	"undefined-type": () => "Expected undefined.",
+	"absolute-path-constraint": () => "Expected an absolute path.",
+	"allowed-characters-constraint": (source) => `Expected a string containing only characters from ${join(coalescing(source.definition.charactersRange), ", ")}.`,
+	"array-length-equal-constraint": (source) => `Expected an array containing exactly ${source.definition.length} elements.`,
+	"between-than-constraint": (source) => `Expected a number greater than ${source.definition.greater} and less than ${source.definition.less}.`,
+	"between-than-or-equal-constraint": (source) => `Expected a number greater than or equal to ${source.definition.greater} and less than or equal to ${source.definition.less}.`,
+	"email-constraint": () => "Expected a valid email address.",
+	"even-constraint": () => "Expected an even number.",
+	"greater-than-constraint": (source) => `Expected a number greater than ${source.definition.threshold}.`,
+	"greater-than-or-equal-constraint": (source) => `Expected a number greater than or equal to ${source.definition.threshold}.`,
+	"integer-constraint": () => "Expected an integer.",
+	"less-than-constraint": (source) => `Expected a number less than ${source.definition.threshold}.`,
+	"less-than-or-equal-constraint": (source) => `Expected a number less than or equal to ${source.definition.threshold}.`,
+	"max-characters-constraint": (source) => `Expected a string containing at most ${source.definition.max} characters.`,
+	"max-elements-constraint": (source) => `Expected an array containing at most ${source.definition.max} elements.`,
+	"min-characters-constraint": (source) => `Expected a string containing at least ${source.definition.min} characters.`,
+	"min-elements-constraint": (source) => `Expected an array containing at least ${source.definition.min} elements.`,
+	"multiple-of-constraint": (source) => `Expected a multiple of ${source.definition.multiple}.`,
+	"negative-constraint": () => "Expected a number less than or equal to zero.",
+	"not-empty-constraint": () => "Expected a non-empty string.",
+	"not-zero-constraint": () => "Expected a non-zero number.",
+	"number-in-string-constraint": () => "Expected a string representing a number.",
+	"odd-constraint": () => "Expected an odd number.",
+	"path-constraint": () => "Expected a valid path.",
+	"positive-constraint": () => "Expected a number greater than or equal to zero.",
+	"refine-constraint": () => "Expected a value satisfying the custom refinement.",
+	"regex-constraint": (source) => `Expected a string matching ${source.definition.regex.toString()}.`,
+	"safe-constraint": () => "Expected a number strictly between Number.MIN_SAFE_INTEGER and Number.MAX_SAFE_INTEGER.",
+	"segment-path-constraint": () => "Expected a valid path segment.",
+	"strict-negative-constraint": () => "Expected a number less than zero.",
+	"strict-positive-constraint": () => "Expected a number greater than zero.",
+	"string-length-equal-constraint": (source) => `Expected a string containing exactly ${source.definition.length} characters.`,
+	"trimmed-constraint": () => "Expected a string without leading or trailing whitespace.",
+	"url-constraint": () => "Expected a valid URL.",
+	"uuid-constraint": () => "Expected a valid UUID."
+};
+const createDefaultCodecErrorMessage = (codecName, encodedValueDescription, decodedValueDescription) => (_codec, issue) => {
+	if (issue.from === "predicate") return encodeIssueKind.has(issue) ? `The ${codecName} codec must produce ${encodedValueDescription}.` : `Expected ${encodedValueDescription} for the ${codecName} codec.`;
+	if (issue.from === "encoding") return `The ${codecName} codec could not encode ${decodedValueDescription}.`;
+	if (issue.from === "decoding") return `The ${codecName} codec could not decode the value as ${decodedValueDescription}.`;
+	return `The ${codecName} codec encountered an external error while ${encodeIssueKind.has(issue) ? "encoding" : "decoding"}.`;
+};
+const defaultErrorInterpreterCodecDictionary = [
+	[codecsJson.definition.bigint, createDefaultCodecErrorMessage("JSON bigint", "a string", "a bigint")],
+	[codecsJson.definition.date, createDefaultCodecErrorMessage("JSON date", "a string", "a DuploJS date")],
+	[codecsJson.definition.time, createDefaultCodecErrorMessage("JSON time", "a string", "a DuploJS time")],
+	[codecsString.definition.bigint, createDefaultCodecErrorMessage("string bigint", "a string", "a bigint")],
+	[codecsString.definition.boolean, createDefaultCodecErrorMessage("string boolean", "the string \"true\" or \"false\"", "a boolean")],
+	[codecsString.definition.date, createDefaultCodecErrorMessage("string date", "a string", "a DuploJS date")],
+	[codecsString.definition.null, createDefaultCodecErrorMessage("string null", "the string \"null\"", "null")],
+	[codecsString.definition.number, createDefaultCodecErrorMessage("string number", "a string representing a number", "a finite number")],
+	[codecsString.definition.time, createDefaultCodecErrorMessage("string time", "a string", "a DuploJS time")],
+	[codecsString.definition.undefined, createDefaultCodecErrorMessage("string undefined", "the string \"undefined\"", "undefined")]
+];
+//#endregion
+export { defaultErrorInterpreterCodecDictionary, defaultErrorInterpreterDataStructureDictionary };

package/dist/dataStructure/common/error/index.d.ts

@@ -0,0 +1,3 @@
+export * from './base';
+export * from './interpreter';
+export * from './defaultInterpreter';

package/dist/dataStructure/common/error/interpreter.cjs

@@ -0,0 +1,45 @@
+const require_base = require("../../../kind/base.cjs");
+const require_entries = require("../../../object/entries.cjs");
+const require_entry = require("../../../object/entry.cjs");
+const require_map = require("../../../array/map.cjs");
+const require_reduce = require("../../../array/reduce.cjs");
+const require_pipe = require("../../../common/pipe.cjs");
+const require_base$1 = require("./base.cjs");
+//#region scripts/dataStructure/common/error/interpreter.ts
+const kindNamespaceName = "DuplojsLangDataStructure";
+function createErrorInterpreter(structureDictionary = {}, codecDictionary = []) {
+	const formattedStructureDictionary = require_pipe.pipe(structureDictionary, require_entries.entries, require_map.map(([key, value]) => require_entry.entry(`${require_base.keyKindPrefix}@${kindNamespaceName}/${key}`, value)));
+	const getInterpretedMessageStructure = (structure, issue) => require_reduce.reduce(formattedStructureDictionary, require_reduce.reduceFrom(void 0), ({ element: [key, getMessage], next, exit }) => getMessage && key in structure ? exit(getMessage(structure, issue)) : next(void 0));
+	const getInterpretedMessageCodec = (codec, issue) => require_reduce.reduce(codecDictionary, require_reduce.reduceFrom(void 0), ({ element: [currentCodec, message], next, exit }) => currentCodec === codec ? exit(message(codec, issue)) : next(void 0));
+	return (error) => require_map.map(error.issues, (issue) => {
+		if (require_base$1.issueKind.has(issue)) {
+			const source = issue.getSource();
+			const subSource = issue.getSubSource?.();
+			return {
+				...issue,
+				interpretedMessage: {
+					source: source.definition.message,
+					subSource: subSource?.definition.message,
+					interpretedSource: getInterpretedMessageStructure(source, issue),
+					interpretedSubSource: subSource && getInterpretedMessageStructure(subSource, issue)
+				}
+			};
+		}
+		if (require_base$1.encodeIssueKind.has(issue)) return {
+			...issue,
+			interpretedMessage: {
+				source: issue.message,
+				interpretedSource: getInterpretedMessageCodec(issue.getSource(), issue)
+			}
+		};
+		return {
+			...issue,
+			interpretedMessage: {
+				source: issue.message,
+				interpretedSource: getInterpretedMessageCodec(issue.getSource(), issue)
+			}
+		};
+	});
+}
+//#endregion
+exports.createErrorInterpreter = createErrorInterpreter;

package/dist/dataStructure/common/error/interpreter.d.ts

@@ -0,0 +1,36 @@
+import { Structure, Structures } from '../../structure';
+import { createKind } from '../../kind';
+import { Type, Types } from '../../type';
+import { Constraint, Constraints } from '../../constraint';
+import { Error, DecodeIssue, EncodeIssue, Issue } from './base';
+import { Codec } from '../codec';
+import * as DKind from '../../../kind';
+import * as DCommon from '../../../common';
+declare const kindNamespaceName: DKind.GetNamespaceName<typeof createKind>;
+type RemoveNamespace<GenericString> = GenericString extends `@${typeof kindNamespaceName}/${infer InferredKindName}` ? InferredKindName : never;
+export interface InterpretedMessage {
+    source?: string;
+    interpretedSource?: string;
+    subSource?: string;
+    interpretedSubSource?: string;
+}
+export interface InterpretedIssue extends Issue {
+    interpretedMessage: InterpretedMessage;
+}
+export interface InterpretedEncodedIssue extends EncodeIssue {
+    interpretedMessage: InterpretedMessage;
+}
+export interface InterpretedDecodedIssue extends DecodeIssue {
+    interpretedMessage: InterpretedMessage;
+}
+export type InterpretedIssues = (InterpretedIssue | InterpretedEncodedIssue | InterpretedDecodedIssue);
+export type StructureDictionaryParams = DCommon.SimplifyTopLevel<Omit<{
+    [DataStructure in (Types | Structures | Constraints) as RemoveNamespace<DKind.GetName<DataStructure>>]?: (structure: DataStructure, issue: Issue) => string;
+}, RemoveNamespace<DKind.GetName<Type>> | RemoveNamespace<DKind.GetName<Structure>> | RemoveNamespace<DKind.GetName<Constraint>>>>;
+export type CodecDictionaryParams = [
+    Codec,
+    (codec: Codec, issue: EncodeIssue | DecodeIssue) => string
+][];
+export declare function createErrorInterpreter(structureDictionary?: StructureDictionaryParams, codecDictionary?: CodecDictionaryParams): (error: Error) => readonly InterpretedIssues[];
+export type ErrorInterpreter = ReturnType<typeof createErrorInterpreter>;
+export {};

package/dist/dataStructure/common/error/interpreter.mjs

@@ -0,0 +1,45 @@
+import { keyKindPrefix } from "../../../kind/base.mjs";
+import { entries } from "../../../object/entries.mjs";
+import { entry } from "../../../object/entry.mjs";
+import { map } from "../../../array/map.mjs";
+import { reduce, reduceFrom } from "../../../array/reduce.mjs";
+import { pipe } from "../../../common/pipe.mjs";
+import { encodeIssueKind, issueKind } from "./base.mjs";
+//#region scripts/dataStructure/common/error/interpreter.ts
+const kindNamespaceName = "DuplojsLangDataStructure";
+function createErrorInterpreter(structureDictionary = {}, codecDictionary = []) {
+	const formattedStructureDictionary = pipe(structureDictionary, entries, map(([key, value]) => entry(`${keyKindPrefix}@${kindNamespaceName}/${key}`, value)));
+	const getInterpretedMessageStructure = (structure, issue) => reduce(formattedStructureDictionary, reduceFrom(void 0), ({ element: [key, getMessage], next, exit }) => getMessage && key in structure ? exit(getMessage(structure, issue)) : next(void 0));
+	const getInterpretedMessageCodec = (codec, issue) => reduce(codecDictionary, reduceFrom(void 0), ({ element: [currentCodec, message], next, exit }) => currentCodec === codec ? exit(message(codec, issue)) : next(void 0));
+	return (error) => map(error.issues, (issue) => {
+		if (issueKind.has(issue)) {
+			const source = issue.getSource();
+			const subSource = issue.getSubSource?.();
+			return {
+				...issue,
+				interpretedMessage: {
+					source: source.definition.message,
+					subSource: subSource?.definition.message,
+					interpretedSource: getInterpretedMessageStructure(source, issue),
+					interpretedSubSource: subSource && getInterpretedMessageStructure(subSource, issue)
+				}
+			};
+		}
+		if (encodeIssueKind.has(issue)) return {
+			...issue,
+			interpretedMessage: {
+				source: issue.message,
+				interpretedSource: getInterpretedMessageCodec(issue.getSource(), issue)
+			}
+		};
+		return {
+			...issue,
+			interpretedMessage: {
+				source: issue.message,
+				interpretedSource: getInterpretedMessageCodec(issue.getSource(), issue)
+			}
+		};
+	});
+}
+//#endregion
+export { createErrorInterpreter };

package/dist/dataStructure/constraint/base.cjs

@@ -1,17 +1,46 @@
+const require_bindPrototypeMethods = require("../../common/bindPrototypeMethods.cjs");
+const require_simpleClone = require("../../common/simpleClone.cjs");
 //#region scripts/dataStructure/constraint/base.ts
 const constraintKind = require("../kind.cjs").createKind("constraint");
+var ConstraintBase = class ConstraintBase {
+	constructor() {}
+	static init(params) {
+		const self = new ConstraintBase();
+		require_bindPrototypeMethods.bindPrototypeMethods(self);
+		for (const key in params) self[key] = params[key];
+		return self;
+	}
+	static addToPrototype(prop, value) {
+		ConstraintBase.prototype[prop] = typeof value === "function" ? function(...args) {
+			return value(this, ...args);
+		} : value;
+	}
+};
 function createConstraint(kindHandler, createConstructor) {
-	return createConstructor({ init: (definition, { executeCheck, isAsynchronous }) => {
-		const self = {
+	const init = (definition, { executeCheck, isAsynchronous }) => {
+		const self = ConstraintBase.init({
 			definition,
-			executeCheck: (data, errorHandler) => executeCheck(self, data, errorHandler),
+			executeCheck: (data) => executeCheck(self, data),
 			isAsynchronous: () => isAsynchronous(self),
+			clone: () => init(require_simpleClone.simpleClone(definition), {
+				executeCheck,
+				isAsynchronous
+			}),
+			setMessage: (message) => {
+				self.definition.message = message;
+				return self;
+			},
+			addMessage: (message) => {
+				return self.clone().setMessage(message);
+			},
 			[constraintKind.runTimeKey]: null,
 			[kindHandler.runTimeKey]: null
-		};
+		});
 		return self;
-	} });
+	};
+	return createConstructor({ init });
 }
 //#endregion
+exports.ConstraintBase = ConstraintBase;
 exports.constraintKind = constraintKind;
 exports.createConstraint = createConstraint;

package/dist/dataStructure/constraint/base.d.ts

@@ -1,20 +1,29 @@
-import { SuccessSymbol, ErrorSymbol, GetErrorHandler } from '../common';
+import { SuccessSymbol, ErrorSymbol } from '../common';
 import type * as DKind from '../../kind';
-import type * as DCommon from '../../common';
+import * as DCommon from '../../common';
 export declare const constraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/constraint", unknown>>;
 export interface ConstraintDefinition {
+    readonly message?: string;
 }
 declare const BivariousSymbol: unique symbol;
 export interface Constraint<GenericInput extends unknown = unknown, GenericChecked extends GenericInput = GenericInput, GenericDefinition extends ConstraintDefinition = ConstraintDefinition> extends DKind.Kind<typeof constraintKind, DCommon.IsEqual<GenericInput, GenericChecked> extends true ? any : GenericChecked> {
     readonly definition: GenericDefinition;
     readonly [BivariousSymbol]?: DCommon.IsUnion<GenericInput> extends true ? (input: GenericInput) => void : unknown;
-    executeCheck(data: GenericInput, errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
+    executeCheck(data: GenericInput): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
     isAsynchronous(): boolean;
+    clone(): this;
+    setMessage(massage: string): this;
+    addMessage(massage: string): this;
 }
 export interface CreateConstraintInitParams<GenericConstraint extends Constraint = Constraint> {
-    executeCheck(self: GenericConstraint, data: Parameters<GenericConstraint["executeCheck"]>[0], errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
+    executeCheck(self: GenericConstraint, data: Parameters<GenericConstraint["executeCheck"]>[0]): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
     isAsynchronous(self: GenericConstraint): boolean;
 }
+export declare class ConstraintBase {
+    private constructor();
+    static init(params: DKind.Remove<Constraint>): Constraint;
+    static addToPrototype<GenericProp extends keyof Constraint>(prop: GenericProp, value: Constraint[GenericProp] extends infer InferredValue ? InferredValue extends DCommon.AnyFunction ? (self: Constraint, ...rest: Parameters<InferredValue>) => ReturnType<InferredValue> : Constraint[GenericProp] : never): void;
+}
 export interface CreateConstraintConstructorParams<GenericKindHandler extends DKind.Handler = DKind.Handler> {
     init<GenericConstraint extends (Constraint & DKind.Kind<GenericKindHandler>)>(definition: GenericConstraint["definition"], params: CreateConstraintInitParams<GenericConstraint>): GenericConstraint;
 }

package/dist/dataStructure/constraint/base.mjs

@@ -1,17 +1,45 @@
+import { bindPrototypeMethods } from "../../common/bindPrototypeMethods.mjs";
+import { simpleClone } from "../../common/simpleClone.mjs";
 import { createKind } from "../kind.mjs";
 //#region scripts/dataStructure/constraint/base.ts
 const constraintKind = createKind("constraint");
+var ConstraintBase = class ConstraintBase {
+	constructor() {}
+	static init(params) {
+		const self = new ConstraintBase();
+		bindPrototypeMethods(self);
+		for (const key in params) self[key] = params[key];
+		return self;
+	}
+	static addToPrototype(prop, value) {
+		ConstraintBase.prototype[prop] = typeof value === "function" ? function(...args) {
+			return value(this, ...args);
+		} : value;
+	}
+};
 function createConstraint(kindHandler, createConstructor) {
-	return createConstructor({ init: (definition, { executeCheck, isAsynchronous }) => {
-		const self = {
+	const init = (definition, { executeCheck, isAsynchronous }) => {
+		const self = ConstraintBase.init({
 			definition,
-			executeCheck: (data, errorHandler) => executeCheck(self, data, errorHandler),
+			executeCheck: (data) => executeCheck(self, data),
 			isAsynchronous: () => isAsynchronous(self),
+			clone: () => init(simpleClone(definition), {
+				executeCheck,
+				isAsynchronous
+			}),
+			setMessage: (message) => {
+				self.definition.message = message;
+				return self;
+			},
+			addMessage: (message) => {
+				return self.clone().setMessage(message);
+			},
 			[constraintKind.runTimeKey]: null,
 			[kindHandler.runTimeKey]: null
-		};
+		});
 		return self;
-	} });
+	};
+	return createConstructor({ init });
 }
 //#endregion
-export { constraintKind, createConstraint };
+export { ConstraintBase, constraintKind, createConstraint };

package/dist/dataStructure/constraint/defaults/absolutePath.cjs

@@ -0,0 +1,13 @@
+const require_kind = require("../../kind.cjs");
+const require_resultSymbol = require("../../common/resultSymbol.cjs");
+const require_base = require("../base.cjs");
+const require_isAbsolute = require("../../../path/isAbsolute.cjs");
+//#region scripts/dataStructure/constraint/defaults/absolutePath.ts
+const absolutePathConstraintKind = require_kind.createKind("absolute-path-constraint");
+const AbsolutePathConstraint = require_base.createConstraint(absolutePathConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => require_isAbsolute.isAbsolute(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.AbsolutePathConstraint = AbsolutePathConstraint;
+exports.absolutePathConstraintKind = absolutePathConstraintKind;

package/dist/dataStructure/constraint/defaults/absolutePath.d.ts

@@ -0,0 +1,10 @@
+import { ConstraintDefinition, Constraint } from '../base';
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+import * as DPath from '../../../path';
+export declare const absolutePathConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/absolute-path-constraint", unknown>>;
+export interface AbsolutePathConstraintDefinition extends ConstraintDefinition {
+}
+export interface AbsolutePathConstraint extends DCommon.Forward<Constraint<string, string & DPath.Absolute, AbsolutePathConstraintDefinition> & DKind.Kind<typeof absolutePathConstraintKind>> {
+}
+export declare const AbsolutePathConstraint: () => AbsolutePathConstraint;

package/dist/dataStructure/constraint/defaults/absolutePath.mjs

@@ -0,0 +1,12 @@
+import { createKind } from "../../kind.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
+import { createConstraint } from "../base.mjs";
+import { isAbsolute } from "../../../path/isAbsolute.mjs";
+//#region scripts/dataStructure/constraint/defaults/absolutePath.ts
+const absolutePathConstraintKind = createKind("absolute-path-constraint");
+const AbsolutePathConstraint = createConstraint(absolutePathConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => isAbsolute(data) ? SuccessSymbol : ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { AbsolutePathConstraint, absolutePathConstraintKind };

package/dist/dataStructure/constraint/defaults/allowedCharacters.cjs

@@ -5,7 +5,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/constraint/defaults/allowedCharacters.ts
 const allowedCharactersConstraintKind = require_kind.createKind("allowed-characters-constraint");
 const AllowedCharactersConstraint = require_base.createConstraint(allowedCharactersConstraintKind, ({ init }) => (charactersRange) => init({ charactersRange }, {
-	executeCheck: (self, data, errorHandler) => require_isComposedOf.isComposedOf(data, self.definition.charactersRange) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => require_isComposedOf.isComposedOf(data, self.definition.charactersRange) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/allowedCharacters.d.ts

@@ -3,11 +3,9 @@ import type * as DCommon from '../../../common';
 import type * as DKind from '../../../kind';
 import * as DString from '../../../string';
 export declare const allowedCharactersConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/allowed-characters-constraint", unknown>>;
-type AllowedCharactersConstraintValue<GenericCharactersRange extends DString.CharactersRange> = string & DCommon.UnionToIntersection<GenericCharactersRange extends any ? DString.AllowedCharacters<GenericCharactersRange> : never>;
 export interface AllowedCharactersConstraintDefinition<GenericCharactersRange extends DString.CharactersRange = DString.CharactersRange> extends ConstraintDefinition {
     readonly charactersRange: DCommon.MaybeArray<GenericCharactersRange>;
 }
-export interface AllowedCharactersConstraint<GenericCharactersRange extends DString.CharactersRange = DString.CharactersRange> extends DCommon.UnionToIntersection<Constraint<string, AllowedCharactersConstraintValue<GenericCharactersRange>, AllowedCharactersConstraintDefinition<GenericCharactersRange>> & DKind.Kind<typeof allowedCharactersConstraintKind>> {
+export interface AllowedCharactersConstraint<GenericCharactersRange extends DString.CharactersRange = DString.CharactersRange> extends DCommon.Forward<Constraint<string, string & DString.AllowedCharacters<GenericCharactersRange>, AllowedCharactersConstraintDefinition<GenericCharactersRange>> & DKind.Kind<typeof allowedCharactersConstraintKind>> {
 }
 export declare const AllowedCharactersConstraint: <GenericCharactersRange extends DString.CharactersRange>(charactersRange: DCommon.MaybeArray<GenericCharactersRange>) => AllowedCharactersConstraint<GenericCharactersRange>;
-export {};

package/dist/dataStructure/constraint/defaults/allowedCharacters.mjs

@@ -5,7 +5,7 @@ import { createConstraint } from "../base.mjs";
 //#region scripts/dataStructure/constraint/defaults/allowedCharacters.ts
 const allowedCharactersConstraintKind = createKind("allowed-characters-constraint");
 const AllowedCharactersConstraint = createConstraint(allowedCharactersConstraintKind, ({ init }) => (charactersRange) => init({ charactersRange }, {
-	executeCheck: (self, data, errorHandler) => isComposedOf(data, self.definition.charactersRange) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => isComposedOf(data, self.definition.charactersRange) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/arrayLengthEqual.cjs

@@ -6,7 +6,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/constraint/defaults/arrayLengthEqual.ts
 const arrayLengthEqualConstraintKind = require_kind.createKind("array-length-equal-constraint");
 const ArrayLengthEqualConstraint = require_base.createConstraint(arrayLengthEqualConstraintKind, ({ init }) => (length) => init({ length }, {
-	executeCheck: (self, data, errorHandler) => require_lengthEqual.lengthEqual(data, require_forward.forward(self.definition.length)) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => require_lengthEqual.lengthEqual(data, require_forward.forward(self.definition.length)) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/arrayLengthEqual.d.ts

@@ -6,6 +6,6 @@ export declare const arrayLengthEqualConstraintKind: DKind.Handler<DKind.Definit
 export interface ArrayLengthEqualConstraintDefinition<GenericLength extends number = number> extends ConstraintDefinition {
     readonly length: GenericLength;
 }
-export interface ArrayLengthEqualConstraint<GenericLength extends number = number> extends DCommon.UnionToIntersection<Constraint<readonly unknown[], readonly unknown[] & DArray.LengthEqual<GenericLength>, ArrayLengthEqualConstraintDefinition<GenericLength>> & DKind.Kind<typeof arrayLengthEqualConstraintKind>> {
+export interface ArrayLengthEqualConstraint<GenericLength extends number = number> extends DCommon.Forward<Constraint<readonly unknown[], readonly unknown[] & DArray.LengthEqual<GenericLength>, ArrayLengthEqualConstraintDefinition<GenericLength>> & DKind.Kind<typeof arrayLengthEqualConstraintKind>> {
 }
 export declare const ArrayLengthEqualConstraint: <GenericLength extends number>(length: GenericLength) => ArrayLengthEqualConstraint<GenericLength>;

package/dist/dataStructure/constraint/defaults/arrayLengthEqual.mjs

@@ -6,7 +6,7 @@ import { createConstraint } from "../base.mjs";
 //#region scripts/dataStructure/constraint/defaults/arrayLengthEqual.ts
 const arrayLengthEqualConstraintKind = createKind("array-length-equal-constraint");
 const ArrayLengthEqualConstraint = createConstraint(arrayLengthEqualConstraintKind, ({ init }) => (length) => init({ length }, {
-	executeCheck: (self, data, errorHandler) => lengthEqual(data, forward(self.definition.length)) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => lengthEqual(data, forward(self.definition.length)) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion