@duplojs/lang 0.0.1-beta.1 → 0.0.1-beta.10

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

@@ -22,9 +22,11 @@ export type * from './fixDeepFunctionInfer';
 export type * from './forbiddenPromise';
 export type * from './forbiddenUnion';
 export type * from './forcePredicate';
+export type * from './forward';
 export type * from './hasSomething';
 export type * from './isEqual';
 export type * from './isNever';
+export type * from './isObject';
 export type * from './isUnion';
 export type * from './json';
 export type * from './lastUnionElement';
@@ -48,6 +50,7 @@ export type * from './simplifyTopLevel';
 export type * from './simplifyType';
 export type * from './simplifyTypeForce';
 export type * from './sortType';
+export type * from './splitPromise';
 export type * from './toLargeEnsemble';
 export type * from './unionContain';
 export type * from './unionToIntersection';

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

@@ -0,0 +1,8 @@
+import { And } from './and';
+import { IsExtends } from './IsExtends';
+import { IsNever } from './isNever';
+import { Not } from './not';
+export type IsObject<GenericValue extends unknown> = And<[
+    IsExtends<GenericValue, object>,
+    Not<IsNever<keyof GenericValue>>
+]>;

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

@@ -1,4 +1,4 @@
 import { MaybeArray } from './maybeArray';
 export type Json = MaybeArray<string | undefined | boolean | number | null | {
-    [key: string]: Json;
+    readonly [key: string]: Json;
 }>;

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

@@ -0,0 +1 @@
+export type SplitPromise<GenericValue extends unknown> = GenericValue extends Promise<infer InferredValue> ? InferredValue extends unknown ? Promise<InferredValue> : never : GenericValue;

package/dist/dataStructure/common/codec/base.cjs

@@ -0,0 +1,29 @@
+const require_callThen = require("../../../common/callThen.cjs");
+const require_memo = require("../../../common/memo.cjs");
+const require_kind = require("../../kind.cjs");
+const require_resultSymbol = require("../resultSymbol.cjs");
+//#region scripts/dataStructure/common/codec/base.ts
+const codecKind = require_kind.createKind("codec");
+const codecsKind = require_kind.createKind("codecs");
+function createCodec(fundamentalType, predicateEncode, encode, decode) {
+	const self = {
+		fundamentalType,
+		predicateEncode: (data) => predicateEncode(data),
+		encode: (data, errorHandler) => require_callThen.callThen(encode(data, self, errorHandler), (encodedData) => encodedData === require_resultSymbol.ErrorSymbol ? errorHandler?.().addEncodeIssue(self, "encoding", data) ?? require_resultSymbol.ErrorSymbol : require_callThen.callThen(predicateEncode(encodedData), (result) => result === false ? errorHandler?.().addEncodeIssue(self, "predicate", encodedData) ?? require_resultSymbol.ErrorSymbol : encodedData)),
+		decode: (data, errorHandler) => require_callThen.callThen(predicateEncode(data), (result) => result === false ? errorHandler?.().addDecodeIssue(self, "predicate", data) ?? require_resultSymbol.ErrorSymbol : require_callThen.callThen(decode(data, self, errorHandler), (decodedData) => decodedData === require_resultSymbol.ErrorSymbol ? errorHandler?.().addDecodeIssue(self, "decoding", data) ?? require_resultSymbol.ErrorSymbol : decodedData)),
+		[codecKind.runTimeKey]: null
+	};
+	return self;
+}
+function createCodecs(definition) {
+	return {
+		context: require_memo.memo(() => new Map(Object.values(definition).map((codec) => [codec.fundamentalType, codec]))),
+		definition,
+		[codecsKind.runTimeKey]: null
+	};
+}
+//#endregion
+exports.codecKind = codecKind;
+exports.codecsKind = codecsKind;
+exports.createCodec = createCodec;
+exports.createCodecs = createCodecs;

package/dist/dataStructure/common/{codec.d.ts → codec/base.d.ts}

@@ -1,13 +1,13 @@
-import { FundamentalTypeValue, FundamentalType } from '../fundamentalType';
-import { GetErrorHandler } from './error';
-import { ErrorSymbol } from './resultSymbol';
-import { DObject } from '../../index.ts';
-import type * as DKind from '../../kind';
-import * as DCommon from '../../common';
+import { FundamentalTypeValue, FundamentalType } from '../../fundamentalType';
+import { GetErrorHandler } from '../error';
+import { ErrorSymbol } from '../resultSymbol';
+import type * as DKind from '../../../kind';
+import * as DCommon from '../../../common';
+import type * as DObject from '../../../object';
 export declare const codecKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/codec", unknown>>;
 export interface Codec<GenericFundamentalType extends FundamentalType = FundamentalType, GenericEncodedValue extends unknown = unknown> extends DKind.Kind<typeof codecKind> {
     readonly fundamentalType: GenericFundamentalType;
-    predicateEncode(input: unknown, errorHandler?: GetErrorHandler): input is GenericEncodedValue;
+    predicateEncode(input: unknown): input is GenericEncodedValue;
     encode(data: FundamentalTypeValue<GenericFundamentalType>, errorHandler?: GetErrorHandler): DCommon.MaybePromise<GenericEncodedValue | ErrorSymbol>;
     decode(data: GenericEncodedValue, errorHandler?: GetErrorHandler): DCommon.MaybePromise<FundamentalTypeValue<GenericFundamentalType> | ErrorSymbol>;
 }
@@ -17,7 +17,7 @@ export interface Codecs<GenericCodecMapper extends Record<string, Codec> = Recor
     readonly definition: GenericCodecMapper;
     readonly context: DCommon.Memoized<CodecContext>;
 }
-export declare function createCodec<GenericFundamentalType extends FundamentalType = FundamentalType, GenericEncodedValue extends unknown = unknown>(fundamentalType: GenericFundamentalType, predicateEncode: (input: unknown, errorHandler?: GetErrorHandler) => input is GenericEncodedValue, encode: (data: FundamentalTypeValue<GenericFundamentalType>, errorHandler?: GetErrorHandler) => DCommon.MaybePromise<GenericEncodedValue | ErrorSymbol>, decode: (data: GenericEncodedValue, errorHandler?: GetErrorHandler) => DCommon.MaybePromise<FundamentalTypeValue<GenericFundamentalType> | ErrorSymbol>): Codec<GenericFundamentalType, GenericEncodedValue>;
+export declare function createCodec<GenericFundamentalType extends FundamentalType = FundamentalType, GenericEncodedValue extends unknown = unknown>(fundamentalType: GenericFundamentalType, predicateEncode: (data: unknown) => data is GenericEncodedValue, encode: (data: FundamentalTypeValue<GenericFundamentalType>, self: Codec<GenericFundamentalType, GenericEncodedValue>, errorHandler?: GetErrorHandler) => DCommon.MaybePromise<GenericEncodedValue | ErrorSymbol>, decode: (data: GenericEncodedValue, self: Codec<GenericFundamentalType, GenericEncodedValue>, errorHandler?: GetErrorHandler) => DCommon.MaybePromise<FundamentalTypeValue<GenericFundamentalType> | ErrorSymbol>): Codec<GenericFundamentalType, GenericEncodedValue>;
 type ForbiddenDuplicateFundamentalType<GenericDefinition extends Record<string, Codec>> = {
     [Prop in keyof GenericDefinition]: [GenericDefinition[Prop]];
 }[keyof GenericDefinition] extends infer InferredResult extends [unknown] ? DCommon.IsEqual<DCommon.RemoveDuplicateInUnion<InferredResult>, InferredResult> extends true ? unknown : DCommon.ComputedTypeError<"Several codecs use the same fundamental type."> : never;

package/dist/dataStructure/common/codec/base.mjs

@@ -0,0 +1,26 @@
+import { callThen } from "../../../common/callThen.mjs";
+import { memo } from "../../../common/memo.mjs";
+import { createKind } from "../../kind.mjs";
+import { ErrorSymbol } from "../resultSymbol.mjs";
+//#region scripts/dataStructure/common/codec/base.ts
+const codecKind = createKind("codec");
+const codecsKind = createKind("codecs");
+function createCodec(fundamentalType, predicateEncode, encode, decode) {
+	const self = {
+		fundamentalType,
+		predicateEncode: (data) => predicateEncode(data),
+		encode: (data, errorHandler) => callThen(encode(data, self, errorHandler), (encodedData) => encodedData === ErrorSymbol ? errorHandler?.().addEncodeIssue(self, "encoding", data) ?? ErrorSymbol : callThen(predicateEncode(encodedData), (result) => result === false ? errorHandler?.().addEncodeIssue(self, "predicate", encodedData) ?? ErrorSymbol : encodedData)),
+		decode: (data, errorHandler) => callThen(predicateEncode(data), (result) => result === false ? errorHandler?.().addDecodeIssue(self, "predicate", data) ?? ErrorSymbol : callThen(decode(data, self, errorHandler), (decodedData) => decodedData === ErrorSymbol ? errorHandler?.().addDecodeIssue(self, "decoding", data) ?? ErrorSymbol : decodedData)),
+		[codecKind.runTimeKey]: null
+	};
+	return self;
+}
+function createCodecs(definition) {
+	return {
+		context: memo(() => new Map(Object.values(definition).map((codec) => [codec.fundamentalType, codec]))),
+		definition,
+		[codecsKind.runTimeKey]: null
+	};
+}
+//#endregion
+export { codecKind, codecsKind, createCodec, createCodecs };

package/dist/dataStructure/common/codec/defaults/index.d.ts

@@ -0,0 +1,2 @@
+export * from './json';
+export * from './string';

package/dist/dataStructure/common/codec/defaults/json.cjs

@@ -0,0 +1,26 @@
+const require_whenHasInformationOtherwise = require("../../../../either/whenHasInformationOtherwise.cjs");
+const require_createDate = require("../../../../chrono/createDate.cjs");
+const require_createTime = require("../../../../chrono/createTime.cjs");
+const require_forward = require("../../../../common/forward.cjs");
+const require_innerPipe = require("../../../../common/innerPipe.cjs");
+const require_justReturn = require("../../../../common/justReturn.cjs");
+const require_to = require("../../../../string/to.cjs");
+const require_resultSymbol = require("../../resultSymbol.cjs");
+const require_base = require("../base.cjs");
+const require_bigint = require("../../../fundamentalType/defaults/bigint.cjs");
+const require_date = require("../../../fundamentalType/defaults/date.cjs");
+const require_time = require("../../../fundamentalType/defaults/time.cjs");
+//#region scripts/dataStructure/common/codec/defaults/json.ts
+const codecsJson = require_base.createCodecs({
+	bigint: require_base.createCodec(require_bigint.TheBigint, (data) => typeof data === "string", require_to.to, (data) => {
+		try {
+			return BigInt(data);
+		} catch {
+			return require_resultSymbol.ErrorSymbol;
+		}
+	}),
+	date: require_base.createCodec(require_date.TheDate, (data) => typeof data === "string", require_to.to, require_innerPipe.innerPipe((value) => require_createDate.createDate({ value }), require_whenHasInformationOtherwise.whenHasInformationOtherwise("date-created", require_forward.forward, require_justReturn.justReturn(require_resultSymbol.ErrorSymbol)))),
+	time: require_base.createCodec(require_time.TheTime, (data) => typeof data === "string", require_to.to, require_innerPipe.innerPipe((value) => require_createTime.createTime({ value }), require_whenHasInformationOtherwise.whenHasInformationOtherwise("time-created", require_forward.forward, require_justReturn.justReturn(require_resultSymbol.ErrorSymbol))))
+});
+//#endregion
+exports.codecsJson = codecsJson;

package/dist/dataStructure/common/codec/defaults/json.d.ts

@@ -0,0 +1,6 @@
+import * as FundamentalType from "../../../fundamentalType";
+export declare const codecsJson: import('../../..').Codecs<{
+    bigint: import('../../..').Codec<FundamentalType.TheBigint, string>;
+    date: import('../../..').Codec<FundamentalType.TheDate, string>;
+    time: import('../../..').Codec<FundamentalType.TheTime, string>;
+}>;

package/dist/dataStructure/common/codec/defaults/json.mjs

@@ -0,0 +1,26 @@
+import { whenHasInformationOtherwise } from "../../../../either/whenHasInformationOtherwise.mjs";
+import { createDate } from "../../../../chrono/createDate.mjs";
+import { createTime } from "../../../../chrono/createTime.mjs";
+import { forward } from "../../../../common/forward.mjs";
+import { innerPipe } from "../../../../common/innerPipe.mjs";
+import { justReturn } from "../../../../common/justReturn.mjs";
+import { to } from "../../../../string/to.mjs";
+import { ErrorSymbol } from "../../resultSymbol.mjs";
+import { createCodec, createCodecs } from "../base.mjs";
+import { TheBigint } from "../../../fundamentalType/defaults/bigint.mjs";
+import { TheDate } from "../../../fundamentalType/defaults/date.mjs";
+import { TheTime } from "../../../fundamentalType/defaults/time.mjs";
+//#region scripts/dataStructure/common/codec/defaults/json.ts
+const codecsJson = createCodecs({
+	bigint: createCodec(TheBigint, (data) => typeof data === "string", to, (data) => {
+		try {
+			return BigInt(data);
+		} catch {
+			return ErrorSymbol;
+		}
+	}),
+	date: createCodec(TheDate, (data) => typeof data === "string", to, innerPipe((value) => createDate({ value }), whenHasInformationOtherwise("date-created", forward, justReturn(ErrorSymbol)))),
+	time: createCodec(TheTime, (data) => typeof data === "string", to, innerPipe((value) => createTime({ value }), whenHasInformationOtherwise("time-created", forward, justReturn(ErrorSymbol))))
+});
+//#endregion
+export { codecsJson };

package/dist/dataStructure/common/codec/defaults/string.cjs

@@ -0,0 +1,44 @@
+const require_whenHasInformationOtherwise = require("../../../../either/whenHasInformationOtherwise.cjs");
+const require_createDate = require("../../../../chrono/createDate.cjs");
+const require_createTime = require("../../../../chrono/createTime.cjs");
+const require_forward = require("../../../../common/forward.cjs");
+const require_innerPipe = require("../../../../common/innerPipe.cjs");
+const require_justReturn = require("../../../../common/justReturn.cjs");
+const require_isNumber = require("../../../../string/isNumber.cjs");
+const require_to = require("../../../../string/to.cjs");
+const require_resultSymbol = require("../../resultSymbol.cjs");
+const require_base = require("../base.cjs");
+const require_bigint = require("../../../fundamentalType/defaults/bigint.cjs");
+const require_boolean = require("../../../fundamentalType/defaults/boolean.cjs");
+const require_date = require("../../../fundamentalType/defaults/date.cjs");
+const require_null = require("../../../fundamentalType/defaults/null.cjs");
+const require_number = require("../../../fundamentalType/defaults/number.cjs");
+const require_time = require("../../../fundamentalType/defaults/time.cjs");
+const require_undefined = require("../../../fundamentalType/defaults/undefined.cjs");
+//#region scripts/dataStructure/common/codec/defaults/string.ts
+const codecsString = require_base.createCodecs({
+	bigint: require_base.createCodec(require_bigint.TheBigint, (data) => typeof data === "string", require_to.to, (data) => {
+		try {
+			return BigInt(data);
+		} catch {
+			return require_resultSymbol.ErrorSymbol;
+		}
+	}),
+	boolean: require_base.createCodec(require_boolean.TheBoolean, (data) => data === "true" || data === "false", require_to.to, (data) => {
+		if (data === "true") return true;
+		return false;
+	}),
+	date: require_base.createCodec(require_date.TheDate, (data) => typeof data === "string", require_to.to, require_innerPipe.innerPipe((value) => require_createDate.createDate({ value }), require_whenHasInformationOtherwise.whenHasInformationOtherwise("date-created", require_forward.forward, require_justReturn.justReturn(require_resultSymbol.ErrorSymbol)))),
+	null: require_base.createCodec(require_null.TheNull, (data) => data === "null", require_to.to, require_justReturn.justReturn(null)),
+	number: require_base.createCodec(require_number.TheNumber, (data) => typeof data === "string" && require_isNumber.isNumber(data), require_to.to, (data) => {
+		try {
+			return Number(data);
+		} catch {
+			return require_resultSymbol.ErrorSymbol;
+		}
+	}),
+	time: require_base.createCodec(require_time.TheTime, (data) => typeof data === "string", require_to.to, require_innerPipe.innerPipe((value) => require_createTime.createTime({ value }), require_whenHasInformationOtherwise.whenHasInformationOtherwise("time-created", require_forward.forward, require_justReturn.justReturn(require_resultSymbol.ErrorSymbol)))),
+	undefined: require_base.createCodec(require_undefined.TheUndefined, (data) => data === "undefined", require_to.to, require_justReturn.justReturn(void 0))
+});
+//#endregion
+exports.codecsString = codecsString;

package/dist/dataStructure/common/codec/defaults/string.d.ts

@@ -0,0 +1,11 @@
+import * as DString from '../../../../string';
+import * as FundamentalType from "../../../fundamentalType";
+export declare const codecsString: import('../../..').Codecs<{
+    bigint: import('../../..').Codec<FundamentalType.TheBigint, string>;
+    boolean: import('../../..').Codec<FundamentalType.TheBoolean, "true" | "false">;
+    date: import('../../..').Codec<FundamentalType.TheDate, string>;
+    null: import('../../..').Codec<FundamentalType.TheNull, "null">;
+    number: import('../../..').Codec<FundamentalType.TheNumber, string & DString.Number>;
+    time: import('../../..').Codec<FundamentalType.TheTime, string>;
+    undefined: import('../../..').Codec<FundamentalType.TheUndefined, "undefined">;
+}>;

package/dist/dataStructure/common/codec/defaults/string.mjs

@@ -0,0 +1,44 @@
+import { whenHasInformationOtherwise } from "../../../../either/whenHasInformationOtherwise.mjs";
+import { createDate } from "../../../../chrono/createDate.mjs";
+import { createTime } from "../../../../chrono/createTime.mjs";
+import { forward } from "../../../../common/forward.mjs";
+import { innerPipe } from "../../../../common/innerPipe.mjs";
+import { justReturn } from "../../../../common/justReturn.mjs";
+import { isNumber } from "../../../../string/isNumber.mjs";
+import { to } from "../../../../string/to.mjs";
+import { ErrorSymbol } from "../../resultSymbol.mjs";
+import { createCodec, createCodecs } from "../base.mjs";
+import { TheBigint } from "../../../fundamentalType/defaults/bigint.mjs";
+import { TheBoolean } from "../../../fundamentalType/defaults/boolean.mjs";
+import { TheDate } from "../../../fundamentalType/defaults/date.mjs";
+import { TheNull } from "../../../fundamentalType/defaults/null.mjs";
+import { TheNumber } from "../../../fundamentalType/defaults/number.mjs";
+import { TheTime } from "../../../fundamentalType/defaults/time.mjs";
+import { TheUndefined } from "../../../fundamentalType/defaults/undefined.mjs";
+//#region scripts/dataStructure/common/codec/defaults/string.ts
+const codecsString = createCodecs({
+	bigint: createCodec(TheBigint, (data) => typeof data === "string", to, (data) => {
+		try {
+			return BigInt(data);
+		} catch {
+			return ErrorSymbol;
+		}
+	}),
+	boolean: createCodec(TheBoolean, (data) => data === "true" || data === "false", to, (data) => {
+		if (data === "true") return true;
+		return false;
+	}),
+	date: createCodec(TheDate, (data) => typeof data === "string", to, innerPipe((value) => createDate({ value }), whenHasInformationOtherwise("date-created", forward, justReturn(ErrorSymbol)))),
+	null: createCodec(TheNull, (data) => data === "null", to, justReturn(null)),
+	number: createCodec(TheNumber, (data) => typeof data === "string" && isNumber(data), to, (data) => {
+		try {
+			return Number(data);
+		} catch {
+			return ErrorSymbol;
+		}
+	}),
+	time: createCodec(TheTime, (data) => typeof data === "string", to, innerPipe((value) => createTime({ value }), whenHasInformationOtherwise("time-created", forward, justReturn(ErrorSymbol)))),
+	undefined: createCodec(TheUndefined, (data) => data === "undefined", to, justReturn(void 0))
+});
+//#endregion
+export { codecsString };

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

@@ -0,0 +1,2 @@
+export * from './base';
+export * from './defaults';

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

@@ -0,0 +1,73 @@
+const require_kind = require("../../kind.cjs");
+//#region scripts/dataStructure/common/error/base.ts
+const issueKind = require_kind.createKind("issue");
+const encodeIssueKind = require_kind.createKind("encode-issue");
+const decodeIssueKind = require_kind.createKind("decode-issue");
+function createErrorHandler(defaultPath) {
+	const issues = [];
+	const currentPath = defaultPath ? [...defaultPath] : [];
+	let currentStagePath = currentPath.length - 1;
+	let currentStage = void 0;
+	return {
+		currentPath,
+		issues,
+		createPathStage: () => {
+			if (currentStage === void 0) currentStage = {
+				setCurrentPath: (path) => {
+					currentPath[currentStagePath] = path;
+				},
+				close: () => {
+					if (currentStagePath === -1) return;
+					if (currentPath.length !== currentStagePath) currentPath.pop();
+					currentStagePath--;
+				}
+			};
+			currentStagePath++;
+			return currentStage;
+		},
+		addIssue: (source, data, subSource) => {
+			issues.push({
+				data,
+				path: currentPath.join("."),
+				getSource: () => source,
+				getSubSource: subSource ? () => subSource : void 0,
+				[issueKind.runTimeKey]: null
+			});
+		},
+		addEncodeIssue: (source, from, data, message) => {
+			issues.push({
+				from,
+				data,
+				path: currentPath.join("."),
+				message,
+				getSource: () => source,
+				[encodeIssueKind.runTimeKey]: null
+			});
+		},
+		addDecodeIssue: (source, from, data, message) => {
+			issues.push({
+				from,
+				data,
+				path: currentPath.join("."),
+				message,
+				getSource: () => source,
+				[decodeIssueKind.runTimeKey]: null
+			});
+		},
+		createError: () => ({ issues }),
+		importIssues: (errorHandler) => void errorHandler.forEach((value) => void issues.push(...typeof value === "function" ? value().issues : value.issues))
+	};
+}
+function createGetErrorHandler(defaultPath) {
+	let errorHandler = void 0;
+	return () => {
+		if (errorHandler === void 0) errorHandler = createErrorHandler(defaultPath);
+		return errorHandler;
+	};
+}
+//#endregion
+exports.createErrorHandler = createErrorHandler;
+exports.createGetErrorHandler = createGetErrorHandler;
+exports.decodeIssueKind = decodeIssueKind;
+exports.encodeIssueKind = encodeIssueKind;
+exports.issueKind = issueKind;

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

@@ -0,0 +1,50 @@
+import { Constraint } from '../../constraint';
+import { Structure } from '../../structure';
+import { Type } from '../../type';
+import { Codec } from '../codec';
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+export declare const issueKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/issue", unknown>>;
+export interface Issue extends DKind.Kind<typeof issueKind> {
+    readonly path: string;
+    readonly data: unknown;
+    getSource(): Structure;
+    getSubSource?(): (Type | Constraint);
+}
+export declare const encodeIssueKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/encode-issue", unknown>>;
+export interface EncodeIssue extends DKind.Kind<typeof encodeIssueKind> {
+    readonly from: "encoding" | "predicate" | "external";
+    readonly path: string;
+    readonly data: unknown;
+    readonly message?: string;
+    getSource(): Codec;
+}
+export declare const decodeIssueKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/decode-issue", unknown>>;
+export interface DecodeIssue extends DKind.Kind<typeof decodeIssueKind> {
+    readonly from: "decoding" | "predicate" | "external";
+    readonly path: string;
+    readonly data: unknown;
+    readonly message?: string;
+    getSource(): Codec;
+}
+export type Issues = (Issue | EncodeIssue | DecodeIssue);
+export interface PathStageErrorHandler {
+    setCurrentPath(path: string): void;
+    close(): void;
+}
+export interface Error {
+    readonly issues: readonly Issues[];
+}
+export interface ErrorHandler {
+    readonly issues: readonly Issues[];
+    readonly currentPath: string[];
+    addIssue(source: ReturnType<Issue["getSource"]>, data: unknown, subSource?: ReturnType<Extract<Issue["getSubSource"], DCommon.AnyFunction>>): void;
+    addEncodeIssue(source: ReturnType<EncodeIssue["getSource"]>, from: EncodeIssue["from"], data: unknown, message?: string): void;
+    addDecodeIssue(source: ReturnType<DecodeIssue["getSource"]>, from: DecodeIssue["from"], data: unknown, message?: string): void;
+    importIssues(errorHandler: (GetErrorHandler | ErrorHandler)[]): void;
+    createPathStage(): PathStageErrorHandler;
+    createError(): Error;
+}
+export declare function createErrorHandler(defaultPath?: string[]): ErrorHandler;
+export type GetErrorHandler = () => ErrorHandler;
+export declare function createGetErrorHandler(defaultPath?: string[]): GetErrorHandler;

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

@@ -0,0 +1,69 @@
+import { createKind } from "../../kind.mjs";
+//#region scripts/dataStructure/common/error/base.ts
+const issueKind = createKind("issue");
+const encodeIssueKind = createKind("encode-issue");
+const decodeIssueKind = createKind("decode-issue");
+function createErrorHandler(defaultPath) {
+	const issues = [];
+	const currentPath = defaultPath ? [...defaultPath] : [];
+	let currentStagePath = currentPath.length - 1;
+	let currentStage = void 0;
+	return {
+		currentPath,
+		issues,
+		createPathStage: () => {
+			if (currentStage === void 0) currentStage = {
+				setCurrentPath: (path) => {
+					currentPath[currentStagePath] = path;
+				},
+				close: () => {
+					if (currentStagePath === -1) return;
+					if (currentPath.length !== currentStagePath) currentPath.pop();
+					currentStagePath--;
+				}
+			};
+			currentStagePath++;
+			return currentStage;
+		},
+		addIssue: (source, data, subSource) => {
+			issues.push({
+				data,
+				path: currentPath.join("."),
+				getSource: () => source,
+				getSubSource: subSource ? () => subSource : void 0,
+				[issueKind.runTimeKey]: null
+			});
+		},
+		addEncodeIssue: (source, from, data, message) => {
+			issues.push({
+				from,
+				data,
+				path: currentPath.join("."),
+				message,
+				getSource: () => source,
+				[encodeIssueKind.runTimeKey]: null
+			});
+		},
+		addDecodeIssue: (source, from, data, message) => {
+			issues.push({
+				from,
+				data,
+				path: currentPath.join("."),
+				message,
+				getSource: () => source,
+				[decodeIssueKind.runTimeKey]: null
+			});
+		},
+		createError: () => ({ issues }),
+		importIssues: (errorHandler) => void errorHandler.forEach((value) => void issues.push(...typeof value === "function" ? value().issues : value.issues))
+	};
+}
+function createGetErrorHandler(defaultPath) {
+	let errorHandler = void 0;
+	return () => {
+		if (errorHandler === void 0) errorHandler = createErrorHandler(defaultPath);
+		return errorHandler;
+	};
+}
+//#endregion
+export { createErrorHandler, createGetErrorHandler, decodeIssueKind, encodeIssueKind, issueKind };

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;