@duplojs/lang 0.0.0 → 0.0.1-beta.10

package/dist/common/isType.d.ts

@@ -1,3 +1,4 @@
+import { RemoveConstraint } from './constraint';
 import { IsEqual, AnyFunction, AnyValue, BreakGenericLink } from './types';
 interface Type {
     string: [string, never];
@@ -17,6 +18,6 @@ type ComputeResult<GenericInput extends unknown, GenericTypeEntry extends Type[k
 type EligibleType<GenericInput extends unknown> = {
     [Prop in keyof Type]: IsEqual<ComputeResult<GenericInput, Type[Prop]>, never> extends true ? never : Prop;
 }[keyof Type];
-export declare function isType<GenericInput extends AnyValue, GenericType extends EligibleType<GenericInput>>(type: GenericType): (input: GenericInput) => input is ComputeResult<BreakGenericLink<GenericInput>, Type[GenericType]>;
-export declare function isType<GenericInput extends AnyValue, GenericType extends EligibleType<GenericInput>>(input: GenericInput, type: GenericType): input is ComputeResult<GenericInput, Type[GenericType]>;
+export declare function isType<GenericInput extends AnyValue, GenericType extends EligibleType<RemoveConstraint<GenericInput>>>(type: GenericType): (input: GenericInput) => input is ComputeResult<BreakGenericLink<GenericInput>, Type[GenericType]>;
+export declare function isType<GenericInput extends AnyValue, GenericType extends EligibleType<RemoveConstraint<GenericInput>>>(input: GenericInput, type: GenericType): input is ComputeResult<GenericInput, Type[GenericType]>;
 export {};

package/dist/common/queue.cjs

@@ -12,13 +12,15 @@ function createQueue(params) {
 		const externalPromise = require_externalPromise.createExternalPromise();
 		const preparedTask = () => {
 			runningCount++;
-			if (firstElement?.task === preparedTask) if (firstElement === firstElement.next) firstElement = void 0;
-			else {
-				const newFirst = firstElement.next;
-				const last = firstElement.previous;
-				newFirst.previous = last;
-				last.next = newFirst;
-				firstElement = newFirst;
+			if (firstElement?.task === preparedTask) {
+				if (firstElement === firstElement.next) firstElement = void 0;
+				else {
+					const newFirst = firstElement.next;
+					const last = firstElement.previous;
+					newFirst.previous = last;
+					last.next = newFirst;
+					firstElement = newFirst;
+				}
 			}
 			let taskResult = void 0;
 			try {

package/dist/common/queue.mjs

@@ -12,13 +12,15 @@ function createQueue(params) {
 		const externalPromise = createExternalPromise();
 		const preparedTask = () => {
 			runningCount++;
-			if (firstElement?.task === preparedTask) if (firstElement === firstElement.next) firstElement = void 0;
-			else {
-				const newFirst = firstElement.next;
-				const last = firstElement.previous;
-				newFirst.previous = last;
-				last.next = newFirst;
-				firstElement = newFirst;
+			if (firstElement?.task === preparedTask) {
+				if (firstElement === firstElement.next) firstElement = void 0;
+				else {
+					const newFirst = firstElement.next;
+					const last = firstElement.previous;
+					newFirst.previous = last;
+					last.next = newFirst;
+					firstElement = newFirst;
+				}
 			}
 			let taskResult = void 0;
 			try {

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

@@ -0,0 +1 @@
+export type Forward<GenericValue extends unknown> = GenericValue;

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 };