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

package/README.md

@@ -1,3 +1,9 @@
-# Temporary Holding Version
+# @duplojs/server
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![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,17 @@
+//#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;
+};
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+//#endregion
+export { __exportAll, __require };

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, ForbiddenInvalidIdentifier } 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 & ForbiddenInvalidIdentifier<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,102 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("./kind.cjs");
+const require_error = require("./error.cjs");
+const require_base = require("./options/base.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,
+				hasError: false
+			}), async ({ item: option, lastValue, next }) => {
+				const optionResult = await option.execute(lastValue.restArgs, error);
+				if (optionResult === require_error.SymbolCommandError) return next(_duplojs_lang_object.override(lastValue, { hasError: true }));
+				return next({
+					options: _duplojs_lang_object.override(lastValue.options, { [option.name]: optionResult.result }),
+					restArgs: optionResult.argumentRest,
+					hasError: lastValue.hasError
+				});
+			});
+			if (commandOptions.hasError === true) return require_error.SymbolCommandError;
+			const unknownOptions = _duplojs_lang_array.filter(commandOptions.restArgs, require_base.isOptionToken);
+			if (unknownOptions.length > 0) return error.addUnknownOptionIssue(unknownOptions);
+			if (self.subject?.type === "argument") {
+				if (self.subject.args.length < commandOptions.restArgs.length) return error.addTooMuchCommandArgumentIssue(self.subject.args.length, commandOptions.restArgs.length);
+				const commandArgs = 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 (commandArgs === require_error.SymbolCommandError) return require_error.SymbolCommandError;
+				await execute({
+					options: commandOptions.options,
+					args: commandArgs.args
+				});
+			} else {
+				if (commandOptions.restArgs.length > 0) {
+					if (self.subject?.type === "subCommand") return error.addUnknownSubCommandIssue(commandOptions.restArgs[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, ForbiddenInvalidIdentifier } 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 & ForbiddenInvalidIdentifier<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 & ForbiddenInvalidIdentifier<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,96 @@
+import { createKind } from "./kind.mjs";
+import { SymbolCommandError } from "./error.mjs";
+import { isOptionToken } from "./options/base.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,
+				hasError: false
+			}), async ({ item: option, lastValue, next }) => {
+				const optionResult = await option.execute(lastValue.restArgs, error);
+				if (optionResult === SymbolCommandError) return next(DObject.override(lastValue, { hasError: true }));
+				return next({
+					options: DObject.override(lastValue.options, { [option.name]: optionResult.result }),
+					restArgs: optionResult.argumentRest,
+					hasError: lastValue.hasError
+				});
+			});
+			if (commandOptions.hasError === true) return SymbolCommandError;
+			const unknownOptions = DArray.filter(commandOptions.restArgs, isOptionToken);
+			if (unknownOptions.length > 0) return error.addUnknownOptionIssue(unknownOptions);
+			if (self.subject?.type === "argument") {
+				if (self.subject.args.length < commandOptions.restArgs.length) return error.addTooMuchCommandArgumentIssue(self.subject.args.length, commandOptions.restArgs.length);
+				const commandArgs = 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 (commandArgs === SymbolCommandError) return SymbolCommandError;
+				await execute({
+					options: commandOptions.options,
+					args: commandArgs.args
+				});
+			} else {
+				if (commandOptions.restArgs.length > 0) {
+					if (self.subject?.type === "subCommand") return error.addUnknownSubCommandIssue(commandOptions.restArgs[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,206 @@
+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_pattern = require("@duplojs/lang/pattern");
+_duplojs_lang_pattern = require_runtime.__toESM(_duplojs_lang_pattern, 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_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),
+		addUnknownOptionIssue: (optionTokens) => {
+			issues.push(_duplojs_lang_modeling.taggedObject("UnknownOptionIssue", {
+				optionTokens,
+				path: _duplojs_lang_string.join(currentPath, ".")
+			}));
+			return SymbolCommandError;
+		},
+		addUnknownSubCommandIssue: (subCommandName) => {
+			issues.push(_duplojs_lang_modeling.taggedObject("UnknownSubCommandIssue", {
+				subCommandName,
+				path: _duplojs_lang_string.join(currentPath, ".")
+			}));
+			return SymbolCommandError;
+		},
+		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.renderLine([
+		"↳ ",
+		_duplojs_lang_printer.colorizedBold(path || "<value>", "cyan"),
+		" : ",
+		_duplojs_lang_printer.colorizedBold(interpretedMessage.subSource ?? interpretedMessage.interpretedSubSource ?? interpretedMessage.source ?? interpretedMessage.interpretedSource ?? "unknown data structure error.", "red")
+	], {
+		joinCharacter: "",
+		indent: _duplojs_lang_printer.Indent.tab,
+		indentLevel: 1
+	})));
+}
+function interpretErrorIssues(issues, dataStructureErrorInterpreter) {
+	return _duplojs_lang_printer.renderParagraph([_duplojs_lang_array.map(issues, _duplojs_lang_pattern.matchWithTaggedObject({
+		UnknownOptionIssue: ({ optionTokens }) => [_duplojs_lang_printer.renderLine([_duplojs_lang_printer.colorizedBold("OPTION: ", "blue"), _duplojs_lang_string.join(optionTokens, ", ")], {
+			joinCharacter: "",
+			indent: _duplojs_lang_printer.Indent.tab,
+			indentLevel: 1
+		}), _duplojs_lang_printer.renderLine(["↳ Unknown Option"], {
+			indent: _duplojs_lang_printer.Indent.tab,
+			indentLevel: 1
+		})],
+		UnknownSubCommandIssue: ({ subCommandName }) => [_duplojs_lang_printer.renderLine([_duplojs_lang_printer.colorizedBold("SUB-COMMAND: ", "cyan"), subCommandName], {
+			joinCharacter: "",
+			indent: _duplojs_lang_printer.Indent.tab,
+			indentLevel: 1
+		}), _duplojs_lang_printer.renderLine(["↳ Unknown Sub-command"], {
+			indent: _duplojs_lang_printer.Indent.tab,
+			indentLevel: 1
+		})],
+		DataStructureArgumentIssue: ({ argumentName, dataStructureError }) => [_duplojs_lang_printer.renderLine([_duplojs_lang_printer.colorizedBold("ARGUMENT: ", "magenta"), `--${argumentName}`], {
+			joinCharacter: "",
+			indent: _duplojs_lang_printer.Indent.tab,
+			indentLevel: 1
+		}), interpretDataStructureError(dataStructureError, dataStructureErrorInterpreter)],
+		RequiredArgumentIssue: ({ argumentName }) => [_duplojs_lang_printer.renderLine([_duplojs_lang_printer.colorizedBold("ARGUMENT: ", "magenta"), argumentName], {
+			joinCharacter: "",
+			indent: _duplojs_lang_printer.Indent.tab,
+			indentLevel: 1
+		}), _duplojs_lang_printer.renderLine(["↳ Missing Argument"], {
+			indent: _duplojs_lang_printer.Indent.tab,
+			indentLevel: 1
+		})],
+		DataStructureOptionIssue: ({ optionName, dataStructureError }) => [_duplojs_lang_printer.renderLine([_duplojs_lang_printer.colorizedBold("OPTION: ", "blue"), `--${optionName}`], {
+			joinCharacter: "",
+			indent: _duplojs_lang_printer.Indent.tab,
+			indentLevel: 1
+		}), interpretDataStructureError(dataStructureError, dataStructureErrorInterpreter)],
+		RequiredOptionIssue: ({ optionName }) => [_duplojs_lang_printer.renderLine([_duplojs_lang_printer.colorizedBold("OPTION: ", "blue"), `--${optionName}`], {
+			joinCharacter: "",
+			indent: _duplojs_lang_printer.Indent.tab,
+			indentLevel: 1
+		}), _duplojs_lang_printer.renderLine(["↳ Missing Option"], {
+			indent: _duplojs_lang_printer.Indent.tab,
+			indentLevel: 1
+		})],
+		RequiredOptionValueIssue: ({ optionName }) => [_duplojs_lang_printer.renderLine([_duplojs_lang_printer.colorizedBold("OPTION: ", "blue"), `--${optionName}`], {
+			joinCharacter: "",
+			indent: _duplojs_lang_printer.Indent.tab,
+			indentLevel: 1
+		}), _duplojs_lang_printer.renderLine(["↳ Missing Option Value"], {
+			indent: _duplojs_lang_printer.Indent.tab,
+			indentLevel: 1
+		})],
+		UnexpectedOptionValueIssue: ({ optionName }) => [_duplojs_lang_printer.renderLine([_duplojs_lang_printer.colorizedBold("OPTION: ", "blue"), `--${optionName}`], {
+			joinCharacter: "",
+			indent: _duplojs_lang_printer.Indent.tab,
+			indentLevel: 1
+		}), _duplojs_lang_printer.renderLine(["↳ Unexpected Value At This Option"], {
+			indent: _duplojs_lang_printer.Indent.tab,
+			indentLevel: 1
+		})],
+		TooMuchCommandArgumentIssue: ({ expect, receive }) => [_duplojs_lang_printer.renderLine([" Too Much Arguments"], {
+			indent: _duplojs_lang_printer.Indent.tab,
+			indentLevel: 1
+		}), _duplojs_lang_printer.renderLine([` expect: ${expect} receive: ${receive}`], {
+			indent: _duplojs_lang_printer.Indent.tab,
+			indentLevel: 1
+		})]
+	})), 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.colorizedBold("Command failed", "red"),
+		_duplojs_lang_printer.renderLine([_duplojs_lang_printer.colorizedBold("COMMAND: ", "cyan"), _duplojs_lang_string.join(error.currentPath, " ")], {
+			joinCharacter: "",
+			indent: _duplojs_lang_printer.Indent.tab,
+			indentLevel: 1
+		}),
+		interpretErrorIssues(error.issues, dataStructureErrorInterpreter ?? defaultDataStructureErrorInterpreter)
+	]);
+}
+function interpretExecOptionsError(error, dataStructureErrorInterpreter) {
+	return _duplojs_lang_printer.renderParagraph([
+		_duplojs_lang_printer.colorizedBold("Invalid options", "red"),
+		["", ""],
+		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,61 @@
+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 UnknownOptionIssue extends CommandArgumentIssueBase, DModeling.ObjectTag<"UnknownOptionIssue"> {
+    readonly optionTokens: readonly string[];
+}
+export interface UnknownSubCommandIssue extends CommandArgumentIssueBase, DModeling.ObjectTag<"UnknownSubCommandIssue"> {
+    readonly subCommandName: 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 | UnknownOptionIssue | UnknownSubCommandIssue);
+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;
+    addUnknownOptionIssue(optionTokens: readonly string[]): SymbolCommandError;
+    addUnknownSubCommandIssue(subCommandName: string): SymbolCommandError;
+    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;