@duplojs/server 0.0.0-stage → 0.1.0-beta.1

package/README

@@ -0,0 +1,9 @@
+# @duplojs/server
+
+[![NPM version](https://img.shields.io/npm/v/@duplojs/server)](https://www.npmjs.com/package/@duplojs/server)
+
+## Install
+
+```bash
+npm install @duplojs/server
+```

package/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,33 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__exportAll = __exportAll;
+exports.__toESM = __toESM;

package/dist/_virtual/_rolldown/runtime.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/dist/command/argument.cjs

@@ -0,0 +1,27 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_string = require("../dataStructure/common/codec/defaults/string.cjs");
+const require_kind = require("./kind.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+//#region scripts/command/argument.ts
+const argumentKind = require_kind.createKind("command-argument");
+function createArgument(name, dataStructure, params) {
+	const self = {
+		name,
+		dataStructure,
+		description: params?.description ?? null,
+		optional: params?.optional ?? false,
+		execute: async (argument, error) => {
+			if (self.optional === false && argument === void 0) return error.addRequiredArgumentIssue(self.name);
+			if (argument === void 0) return;
+			const result = await self.dataStructure.asyncDecode(require_string.codecsString, argument);
+			if (_duplojs_lang_either.isLeft(result)) return error.addDataStructureArgumentIssue(self.name, argument, _duplojs_lang_either.unwrapLeft(result));
+			return _duplojs_lang_either.unwrapRight(result);
+		},
+		[argumentKind.runTimeKey]: null
+	};
+	return self;
+}
+//#endregion
+exports.argumentKind = argumentKind;
+exports.createArgument = createArgument;

package/dist/command/argument.d.ts

@@ -0,0 +1,18 @@
+import { Error, SymbolCommandError } from './error';
+import { EligibleType } from './types';
+import type * as DCommon from "@duplojs/lang/common";
+import type * as DKind from "@duplojs/lang/kind";
+import type * as DDataStructure from "@duplojs/lang/dataStructure";
+export declare const argumentKind: DKind.Handler<DKind.Definition<"@DuplojsServerCommand/command-argument", unknown>>;
+export interface Argument<GenericName extends string = string, GenericValue extends EligibleType = EligibleType> extends DKind.Kind<typeof argumentKind> {
+    readonly name: GenericName;
+    readonly dataStructure: DDataStructure.Structure<GenericValue>;
+    readonly optional: boolean;
+    readonly description: string | null;
+    execute(argument: string | undefined, error: Error): Promise<GenericValue | SymbolCommandError>;
+}
+export interface CreateArgumentParams {
+    readonly description?: string;
+    readonly optional?: boolean;
+}
+export declare function createArgument<GenericName extends string, GenericStructure extends DDataStructure.Structure<EligibleType>, GenericValue extends DDataStructure.StructureValue<GenericStructure>, const GenericParams extends CreateArgumentParams = {}>(name: GenericName, dataStructure: GenericStructure, params?: GenericParams): Argument<GenericName, (GenericValue | (DCommon.IsEqual<GenericParams["optional"], true> extends true ? undefined : never))>;

package/dist/command/argument.mjs

@@ -0,0 +1,24 @@
+import { codecsString } from "../dataStructure/common/codec/defaults/string.mjs";
+import { createKind } from "./kind.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/command/argument.ts
+const argumentKind = createKind("command-argument");
+function createArgument(name, dataStructure, params) {
+	const self = {
+		name,
+		dataStructure,
+		description: params?.description ?? null,
+		optional: params?.optional ?? false,
+		execute: async (argument, error) => {
+			if (self.optional === false && argument === void 0) return error.addRequiredArgumentIssue(self.name);
+			if (argument === void 0) return;
+			const result = await self.dataStructure.asyncDecode(codecsString, argument);
+			if (DEither.isLeft(result)) return error.addDataStructureArgumentIssue(self.name, argument, DEither.unwrapLeft(result));
+			return DEither.unwrapRight(result);
+		},
+		[argumentKind.runTimeKey]: null
+	};
+	return self;
+}
+//#endregion
+export { argumentKind, createArgument };

package/dist/command/create.cjs

@@ -0,0 +1,94 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("./kind.cjs");
+const require_error = require("./error.cjs");
+const require_help = require("./help.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_object = require("@duplojs/lang/object");
+_duplojs_lang_object = require_runtime.__toESM(_duplojs_lang_object, 1);
+let _duplojs_lang_array = require("@duplojs/lang/array");
+_duplojs_lang_array = require_runtime.__toESM(_duplojs_lang_array, 1);
+let _duplojs_lang_generator = require("@duplojs/lang/generator");
+_duplojs_lang_generator = require_runtime.__toESM(_duplojs_lang_generator, 1);
+//#region scripts/command/create.ts
+const commandKind = require_kind.createKind("command");
+function isCommands(input) {
+	return input instanceof Array ? input.every(commandKind.has) : false;
+}
+function create(...args) {
+	const [name, params, execute] = args.length === 2 ? [
+		args[0],
+		{},
+		args[1]
+	] : args;
+	const self = {
+		name,
+		description: params.description ?? null,
+		options: params.options ?? [],
+		subject: _duplojs_lang_common.justExec(() => {
+			if (isCommands(params.subjects)) return {
+				type: "subCommand",
+				subCommands: params.subjects
+			};
+			else if (params.subjects) return {
+				type: "argument",
+				args: params.subjects
+			};
+			return null;
+		}),
+		execute: async (args, error) => {
+			if (self.subject?.type === "subCommand") {
+				for (const command of self.subject.subCommands) if (args[0] === command.name) {
+					error.pushPath(command.name);
+					return command.execute(_duplojs_lang_array.shift(args), error);
+				}
+			}
+			const help = await require_help.helpOption.execute(args, error);
+			if (help === require_error.SymbolCommandError) return require_error.SymbolCommandError;
+			else if (help.result) {
+				require_help.logCommandHelp(self);
+				return;
+			}
+			const commandOptions = await _duplojs_lang_generator.asyncReduce(self.options, _duplojs_lang_generator.reduceFrom({
+				options: {},
+				restArgs: args
+			}), async ({ item: option, lastValue, next, exit }) => {
+				const optionResult = await option.execute(lastValue.restArgs, error);
+				if (optionResult === require_error.SymbolCommandError) return exit(require_error.SymbolCommandError);
+				return next({
+					options: _duplojs_lang_object.override(lastValue.options, { [option.name]: optionResult.result }),
+					restArgs: optionResult.argumentRest
+				});
+			});
+			if (commandOptions === require_error.SymbolCommandError) return require_error.SymbolCommandError;
+			if (self.subject?.type === "argument") {
+				if (self.subject.args.length !== commandOptions.restArgs.length) return error.addTooMuchCommandArgumentIssue(self.subject.args.length, commandOptions.restArgs.length);
+				const commandArguments = await _duplojs_lang_generator.asyncReduce(self.subject.args, _duplojs_lang_generator.reduceFrom({
+					args: {},
+					restArgs: commandOptions.restArgs
+				}), async ({ item: argument, lastValue, next, exit }) => {
+					const firstArgument = _duplojs_lang_array.first(lastValue.restArgs);
+					const argumentResult = await argument.execute(firstArgument, error);
+					if (argumentResult === require_error.SymbolCommandError) return exit(require_error.SymbolCommandError);
+					return next({
+						args: _duplojs_lang_object.override(lastValue.args, { [argument.name]: argumentResult }),
+						restArgs: _duplojs_lang_array.shift(lastValue.restArgs)
+					});
+				});
+				if (commandArguments === require_error.SymbolCommandError) return require_error.SymbolCommandError;
+				await execute({
+					options: commandOptions.options,
+					args: commandArguments.args
+				});
+			} else {
+				if (commandOptions.restArgs.length > 0) return error.addTooMuchCommandArgumentIssue(0, commandOptions.restArgs.length);
+				await execute({ options: commandOptions.options });
+			}
+		},
+		[commandKind.runTimeKey]: null
+	};
+	return self;
+}
+//#endregion
+exports.create = create;
+exports.isCommands = isCommands;

package/dist/command/create.d.ts

@@ -0,0 +1,47 @@
+import { Option } from './options';
+import { SymbolCommandError, Error } from './error';
+import { Argument } from './argument';
+import { ForbiddenDuplicateName } from './types';
+import * as DCommon from "@duplojs/lang/common";
+import type * as DKind from "@duplojs/lang/kind";
+declare const commandKind: DKind.Handler<DKind.Definition<"@DuplojsServerCommand/command", unknown>>;
+export declare function isCommands(input: unknown): input is DCommon.AnyTuple<Command>;
+type CommandSubject = {
+    readonly type: "subCommand";
+    readonly subCommands: readonly Command[];
+} | {
+    readonly type: "argument";
+    readonly args: readonly Argument[];
+};
+export interface Command<GenericName extends string = string> extends DKind.Kind<typeof commandKind> {
+    readonly name: GenericName;
+    readonly description: string | null;
+    readonly subject: CommandSubject | null;
+    readonly options: readonly Option[];
+    execute(args: readonly string[], error: Error): Promise<undefined | SymbolCommandError>;
+}
+export type Subjects = (DCommon.AnyTuple<Argument> | DCommon.AnyTuple<Command>);
+export type ForbiddenBadOrderArguments<GenericSubject extends readonly Subjects[number][], GenericContainOptional extends boolean = false> = GenericSubject extends readonly [
+    Argument<string, infer InferredValue>,
+    ...infer InferredRest extends Argument[]
+] ? DCommon.And<[
+    DCommon.IsEqual<GenericContainOptional, true>,
+    DCommon.Not<DCommon.UnionContain<InferredValue, undefined>>
+]> extends true ? DCommon.ComputedTypeError<"Optional argument can't be define before required argument"> : ForbiddenBadOrderArguments<InferredRest, DCommon.UnionContain<InferredValue, undefined>> : unknown;
+export interface CreateCommandParams<GenericOptions extends DCommon.AnyTuple<Option> = DCommon.AnyTuple<Option>, GenericSubject extends Subjects = Subjects> {
+    readonly description?: string;
+    readonly options?: (GenericOptions & ForbiddenDuplicateName<GenericOptions, "option">);
+    readonly subjects?: (GenericSubject & ForbiddenDuplicateName<GenericSubject, "subject"> & ForbiddenBadOrderArguments<GenericSubject>);
+}
+export type CreateCommandExecuteParams<GenericOptions extends DCommon.AnyTuple<Option>, GenericArguments extends DCommon.AnyTuple<Argument>> = ((DCommon.IsEqual<GenericOptions, never> extends true ? {} : {
+    options: {
+        readonly [GenericOption in GenericOptions[number] as GenericOption["name"]]: Exclude<Awaited<ReturnType<GenericOption["execute"]>>, SymbolCommandError>["result"];
+    };
+}) & (DCommon.IsEqual<GenericArguments, never> extends true ? {} : {
+    args: {
+        readonly [GenericArgument in GenericArguments[number] as GenericArgument["name"]]: Exclude<Awaited<ReturnType<GenericArgument["execute"]>>, SymbolCommandError>;
+    };
+}));
+export declare function create<GenericName extends string>(name: GenericName, execute: () => void): Command<GenericName>;
+export declare function create<GenericName extends string, const GenericOptions extends DCommon.AnyTuple<Option> = never, GenericSubjects extends Subjects = never>(name: GenericName, params: CreateCommandParams<GenericOptions, GenericSubjects>, execute: (params: CreateCommandExecuteParams<GenericOptions, Extract<GenericSubjects, DCommon.AnyTuple<Argument>>>) => DCommon.MaybePromise<void>): Command<GenericName>;
+export {};

package/dist/command/create.mjs

@@ -0,0 +1,88 @@
+import { createKind } from "./kind.mjs";
+import { SymbolCommandError } from "./error.mjs";
+import { helpOption, logCommandHelp } from "./help.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DObject from "@duplojs/lang/object";
+import * as DArray from "@duplojs/lang/array";
+import * as DGenerator from "@duplojs/lang/generator";
+//#region scripts/command/create.ts
+const commandKind = createKind("command");
+function isCommands(input) {
+	return input instanceof Array ? input.every(commandKind.has) : false;
+}
+function create(...args) {
+	const [name, params, execute] = args.length === 2 ? [
+		args[0],
+		{},
+		args[1]
+	] : args;
+	const self = {
+		name,
+		description: params.description ?? null,
+		options: params.options ?? [],
+		subject: DCommon.justExec(() => {
+			if (isCommands(params.subjects)) return {
+				type: "subCommand",
+				subCommands: params.subjects
+			};
+			else if (params.subjects) return {
+				type: "argument",
+				args: params.subjects
+			};
+			return null;
+		}),
+		execute: async (args, error) => {
+			if (self.subject?.type === "subCommand") {
+				for (const command of self.subject.subCommands) if (args[0] === command.name) {
+					error.pushPath(command.name);
+					return command.execute(DArray.shift(args), error);
+				}
+			}
+			const help = await helpOption.execute(args, error);
+			if (help === SymbolCommandError) return SymbolCommandError;
+			else if (help.result) {
+				logCommandHelp(self);
+				return;
+			}
+			const commandOptions = await DGenerator.asyncReduce(self.options, DGenerator.reduceFrom({
+				options: {},
+				restArgs: args
+			}), async ({ item: option, lastValue, next, exit }) => {
+				const optionResult = await option.execute(lastValue.restArgs, error);
+				if (optionResult === SymbolCommandError) return exit(SymbolCommandError);
+				return next({
+					options: DObject.override(lastValue.options, { [option.name]: optionResult.result }),
+					restArgs: optionResult.argumentRest
+				});
+			});
+			if (commandOptions === SymbolCommandError) return SymbolCommandError;
+			if (self.subject?.type === "argument") {
+				if (self.subject.args.length !== commandOptions.restArgs.length) return error.addTooMuchCommandArgumentIssue(self.subject.args.length, commandOptions.restArgs.length);
+				const commandArguments = await DGenerator.asyncReduce(self.subject.args, DGenerator.reduceFrom({
+					args: {},
+					restArgs: commandOptions.restArgs
+				}), async ({ item: argument, lastValue, next, exit }) => {
+					const firstArgument = DArray.first(lastValue.restArgs);
+					const argumentResult = await argument.execute(firstArgument, error);
+					if (argumentResult === SymbolCommandError) return exit(SymbolCommandError);
+					return next({
+						args: DObject.override(lastValue.args, { [argument.name]: argumentResult }),
+						restArgs: DArray.shift(lastValue.restArgs)
+					});
+				});
+				if (commandArguments === SymbolCommandError) return SymbolCommandError;
+				await execute({
+					options: commandOptions.options,
+					args: commandArguments.args
+				});
+			} else {
+				if (commandOptions.restArgs.length > 0) return error.addTooMuchCommandArgumentIssue(0, commandOptions.restArgs.length);
+				await execute({ options: commandOptions.options });
+			}
+		},
+		[commandKind.runTimeKey]: null
+	};
+	return self;
+}
+//#endregion
+export { create, isCommands };

package/dist/command/error.cjs

@@ -0,0 +1,153 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_defaultInterpreter = require("../dataStructure/common/error/defaultInterpreter.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+let _duplojs_lang_array = require("@duplojs/lang/array");
+_duplojs_lang_array = require_runtime.__toESM(_duplojs_lang_array, 1);
+let _duplojs_lang_pattern = require("@duplojs/lang/pattern");
+_duplojs_lang_pattern = require_runtime.__toESM(_duplojs_lang_pattern, 1);
+let _duplojs_lang_string = require("@duplojs/lang/string");
+_duplojs_lang_string = require_runtime.__toESM(_duplojs_lang_string, 1);
+let _duplojs_lang_printer = require("@duplojs/lang/printer");
+_duplojs_lang_printer = require_runtime.__toESM(_duplojs_lang_printer, 1);
+let _duplojs_lang_modeling = require("@duplojs/lang/modeling");
+_duplojs_lang_modeling = require_runtime.__toESM(_duplojs_lang_modeling, 1);
+//#region scripts/command/error.ts
+const SymbolCommandError = Symbol.for("SymbolCommandError");
+function createError(commandName) {
+	const issues = [];
+	const currentPath = [commandName];
+	return {
+		issues,
+		currentPath,
+		pushPath: (path) => void currentPath.push(path),
+		addRequiredOptionIssue: (optionName) => {
+			issues.push(_duplojs_lang_modeling.taggedObject("RequiredOptionIssue", {
+				optionName,
+				data: void 0,
+				path: currentPath.join(".")
+			}));
+			return SymbolCommandError;
+		},
+		addRequiredOptionValueIssue: (optionName) => {
+			issues.push(_duplojs_lang_modeling.taggedObject("RequiredOptionValueIssue", {
+				optionName,
+				data: void 0,
+				path: currentPath.join(".")
+			}));
+			return SymbolCommandError;
+		},
+		addUnexpectedOptionValueIssue: (optionName, data) => {
+			issues.push(_duplojs_lang_modeling.taggedObject("UnexpectedOptionValueIssue", {
+				optionName,
+				data,
+				path: currentPath.join(".")
+			}));
+			return SymbolCommandError;
+		},
+		addDataStructureOptionIssue: (optionName, data, dataStructureError) => {
+			issues.push(_duplojs_lang_modeling.taggedObject("DataStructureOptionIssue", {
+				optionName,
+				data,
+				dataStructureError,
+				path: currentPath.join(".")
+			}));
+			return SymbolCommandError;
+		},
+		addRequiredArgumentIssue: (argumentName) => {
+			issues.push(_duplojs_lang_modeling.taggedObject("RequiredArgumentIssue", {
+				argumentName,
+				data: void 0,
+				path: currentPath.join(".")
+			}));
+			return SymbolCommandError;
+		},
+		addDataStructureArgumentIssue: (argumentName, data, dataStructureError) => {
+			issues.push(_duplojs_lang_modeling.taggedObject("DataStructureArgumentIssue", {
+				argumentName,
+				data,
+				dataStructureError,
+				path: currentPath.join(".")
+			}));
+			return SymbolCommandError;
+		},
+		addTooMuchCommandArgumentIssue: (expect, receive) => {
+			issues.push(_duplojs_lang_modeling.taggedObject("TooMuchCommandArgumentIssue", {
+				expect,
+				receive,
+				path: currentPath.join(".")
+			}));
+			return SymbolCommandError;
+		}
+	};
+}
+function interpretDataStructureError(error, dataStructureErrorInterpreter) {
+	return _duplojs_lang_common.pipe(dataStructureErrorInterpreter(error), _duplojs_lang_array.map(({ interpretedMessage, path }) => _duplojs_lang_printer.render([
+		_duplojs_lang_printer.indent(1),
+		"↳ ",
+		_duplojs_lang_printer.colorizedBold(path || "<value>", "cyan"),
+		" : ",
+		_duplojs_lang_printer.colorizedBold(interpretedMessage.subSource ?? interpretedMessage.interpretedSubSource ?? interpretedMessage.source ?? interpretedMessage.interpretedSource ?? "unknown data structure error.", "red")
+	], "")));
+}
+function interpretErrorIssues(issues, dataStructureErrorInterpreter) {
+	return _duplojs_lang_printer.renderParagraph([_duplojs_lang_array.map(issues, _duplojs_lang_pattern.matchWithTaggedObject({
+		DataStructureArgumentIssue: ({ argumentName, dataStructureError }) => [_duplojs_lang_printer.render([
+			_duplojs_lang_printer.indent(1),
+			_duplojs_lang_printer.colorizedBold("ARGUMENT: ", "magenta"),
+			`--${argumentName}`
+		], ""), interpretDataStructureError(dataStructureError, dataStructureErrorInterpreter)],
+		RequiredArgumentIssue: ({ argumentName }) => [_duplojs_lang_printer.render([
+			_duplojs_lang_printer.indent(1),
+			_duplojs_lang_printer.colorizedBold("ARGUMENT: ", "magenta"),
+			argumentName
+		], ""), `${_duplojs_lang_printer.indent(1)}↳ Missing Argument`],
+		DataStructureOptionIssue: ({ optionName, dataStructureError }) => [_duplojs_lang_printer.render([
+			_duplojs_lang_printer.indent(1),
+			_duplojs_lang_printer.colorizedBold("OPTION: ", "blue"),
+			`--${optionName}`
+		], ""), interpretDataStructureError(dataStructureError, dataStructureErrorInterpreter)],
+		RequiredOptionIssue: ({ optionName }) => [_duplojs_lang_printer.render([
+			_duplojs_lang_printer.indent(1),
+			_duplojs_lang_printer.colorizedBold("OPTION: ", "blue"),
+			`--${optionName}`
+		], ""), `${_duplojs_lang_printer.indent(1)}↳ Missing Option`],
+		RequiredOptionValueIssue: ({ optionName }) => [_duplojs_lang_printer.render([
+			_duplojs_lang_printer.indent(1),
+			_duplojs_lang_printer.colorizedBold("OPTION: ", "blue"),
+			`--${optionName}`
+		], ""), `${_duplojs_lang_printer.indent(1)}↳ Missing Option Value`],
+		UnexpectedOptionValueIssue: ({ optionName }) => [_duplojs_lang_printer.render([
+			_duplojs_lang_printer.indent(1),
+			_duplojs_lang_printer.colorizedBold("OPTION: ", "blue"),
+			`--${optionName}`
+		], ""), `${_duplojs_lang_printer.indent(1)}↳ Unexpected Value At This Option`],
+		TooMuchCommandArgumentIssue: ({ expect, receive }) => [`${_duplojs_lang_printer.indent(1)} Too Much Arguments`, `${_duplojs_lang_printer.indent(1)} expect: ${expect} receive: ${receive}`]
+	})), issues.length === 0 && "No issue found"]);
+}
+const defaultDataStructureErrorInterpreter = _duplojs_lang_dataStructure.createErrorInterpreter(require_defaultInterpreter.defaultErrorInterpreterDataStructureDictionary, require_defaultInterpreter.defaultErrorInterpreterCodecDictionary);
+function interpretExecCommandError(error, dataStructureErrorInterpreter) {
+	return _duplojs_lang_printer.renderParagraph([_duplojs_lang_printer.render([
+		_duplojs_lang_printer.colorizedBold("Command failed", "red"),
+		_duplojs_lang_printer.back,
+		_duplojs_lang_printer.indent(1),
+		_duplojs_lang_printer.colorizedBold("COMMAND: ", "cyan"),
+		_duplojs_lang_string.join(error.currentPath, " ")
+	], ""), interpretErrorIssues(error.issues, dataStructureErrorInterpreter ?? defaultDataStructureErrorInterpreter)]);
+}
+function interpretExecOptionsError(error, dataStructureErrorInterpreter) {
+	return _duplojs_lang_printer.renderParagraph([
+		_duplojs_lang_printer.colorizedBold("Invalid options", "red"),
+		_duplojs_lang_printer.back,
+		interpretErrorIssues(error.issues, dataStructureErrorInterpreter ?? defaultDataStructureErrorInterpreter)
+	]);
+}
+//#endregion
+exports.SymbolCommandError = SymbolCommandError;
+exports.createError = createError;
+exports.interpretDataStructureError = interpretDataStructureError;
+exports.interpretErrorIssues = interpretErrorIssues;
+exports.interpretExecCommandError = interpretExecCommandError;
+exports.interpretExecOptionsError = interpretExecOptionsError;

package/dist/command/error.d.ts

@@ -0,0 +1,53 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+export interface OptionIssueBase {
+    readonly data: unknown;
+    readonly path: string;
+    readonly optionName: string;
+}
+export interface RequiredOptionIssue extends OptionIssueBase, DModeling.ObjectTag<"RequiredOptionIssue"> {
+}
+export interface RequiredOptionValueIssue extends OptionIssueBase, DModeling.ObjectTag<"RequiredOptionValueIssue"> {
+}
+export interface UnexpectedOptionValueIssue extends OptionIssueBase, DModeling.ObjectTag<"UnexpectedOptionValueIssue"> {
+}
+export interface DataStructureOptionIssue extends OptionIssueBase, DModeling.ObjectTag<"DataStructureOptionIssue"> {
+    readonly dataStructureError: DDataStructure.Error;
+}
+export interface ArgumentIssueBase {
+    readonly data: unknown;
+    readonly path: string;
+    readonly argumentName: string;
+}
+export interface RequiredArgumentIssue extends ArgumentIssueBase, DModeling.ObjectTag<"RequiredArgumentIssue"> {
+}
+export interface DataStructureArgumentIssue extends ArgumentIssueBase, DModeling.ObjectTag<"DataStructureArgumentIssue"> {
+    readonly dataStructureError: DDataStructure.Error;
+}
+export interface CommandArgumentIssueBase {
+    readonly path: string;
+}
+export interface TooMuchCommandArgumentIssue extends CommandArgumentIssueBase, DModeling.ObjectTag<"TooMuchCommandArgumentIssue"> {
+    readonly expect: number;
+    readonly receive: number;
+}
+export type Issues = (RequiredOptionIssue | RequiredOptionValueIssue | UnexpectedOptionValueIssue | DataStructureOptionIssue | RequiredArgumentIssue | DataStructureArgumentIssue | TooMuchCommandArgumentIssue);
+export declare const SymbolCommandError: unique symbol;
+export type SymbolCommandError = typeof SymbolCommandError;
+export interface Error {
+    readonly issues: readonly Issues[];
+    readonly currentPath: readonly string[];
+    pushPath(path: string): void;
+    addRequiredOptionIssue(optionName: string): SymbolCommandError;
+    addRequiredOptionValueIssue(optionName: string): SymbolCommandError;
+    addUnexpectedOptionValueIssue(optionName: string, data: unknown): SymbolCommandError;
+    addDataStructureOptionIssue(optionName: string, data: unknown, dataStructureError: DDataStructure.Error): SymbolCommandError;
+    addRequiredArgumentIssue(argumentName: string): SymbolCommandError;
+    addDataStructureArgumentIssue(argumentName: string, data: unknown, dataStructureError: DDataStructure.Error): SymbolCommandError;
+    addTooMuchCommandArgumentIssue(expect: number, receive: number): SymbolCommandError;
+}
+export declare function createError(commandName: string): Error;
+export declare function interpretDataStructureError(error: DDataStructure.Error, dataStructureErrorInterpreter: DDataStructure.ErrorInterpreter): readonly string[];
+export declare function interpretErrorIssues(issues: readonly Issues[], dataStructureErrorInterpreter: DDataStructure.ErrorInterpreter): string;
+export declare function interpretExecCommandError(error: Error, dataStructureErrorInterpreter?: DDataStructure.ErrorInterpreter): string;
+export declare function interpretExecOptionsError(error: Error, dataStructureErrorInterpreter?: DDataStructure.ErrorInterpreter): string;