@duplojs/server 0.1.0-beta.1 → 0.1.0-beta.10

package/dist/_virtual/_rolldown/runtime.mjs

@@ -9,5 +9,9 @@ var __exportAll = (all, no_symbols) => {
 	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 };
+export { __exportAll, __require };

package/dist/command/argument.d.ts

@@ -1,5 +1,5 @@
 import { Error, SymbolCommandError } from './error';
-import { EligibleType } from './types';
+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";
@@ -15,4 +15,4 @@ 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))>;
+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/create.cjs

@@ -1,6 +1,7 @@
 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);
@@ -51,19 +52,23 @@ function create(...args) {
 			}
 			const commandOptions = await _duplojs_lang_generator.asyncReduce(self.options, _duplojs_lang_generator.reduceFrom({
 				options: {},
-				restArgs: args
-			}), async ({ item: option, lastValue, next, exit }) => {
+				restArgs: args,
+				hasError: false
+			}), async ({ item: option, lastValue, next }) => {
 				const optionResult = await option.execute(lastValue.restArgs, error);
-				if (optionResult === require_error.SymbolCommandError) return exit(require_error.SymbolCommandError);
+				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
+					restArgs: optionResult.argumentRest,
+					hasError: lastValue.hasError
 				});
 			});
-			if (commandOptions === require_error.SymbolCommandError) return require_error.SymbolCommandError;
+			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 commandArguments = await _duplojs_lang_generator.asyncReduce(self.subject.args, _duplojs_lang_generator.reduceFrom({
+				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 }) => {
@@ -75,13 +80,16 @@ function create(...args) {
 						restArgs: _duplojs_lang_array.shift(lastValue.restArgs)
 					});
 				});
-				if (commandArguments === require_error.SymbolCommandError) return require_error.SymbolCommandError;
+				if (commandArgs === require_error.SymbolCommandError) return require_error.SymbolCommandError;
 				await execute({
 					options: commandOptions.options,
-					args: commandArguments.args
+					args: commandArgs.args
 				});
 			} else {
-				if (commandOptions.restArgs.length > 0) return error.addTooMuchCommandArgumentIssue(0, commandOptions.restArgs.length);
+				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 });
 			}
 		},

package/dist/command/create.d.ts

@@ -1,7 +1,7 @@
 import { Option } from './options';
 import { SymbolCommandError, Error } from './error';
 import { Argument } from './argument';
-import { ForbiddenDuplicateName } from './types';
+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>>;
@@ -42,6 +42,6 @@ export type CreateCommandExecuteParams<GenericOptions extends DCommon.AnyTuple<O
         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 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

@@ -1,5 +1,6 @@
 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";
@@ -46,19 +47,23 @@ function create(...args) {
 			}
 			const commandOptions = await DGenerator.asyncReduce(self.options, DGenerator.reduceFrom({
 				options: {},
-				restArgs: args
-			}), async ({ item: option, lastValue, next, exit }) => {
+				restArgs: args,
+				hasError: false
+			}), async ({ item: option, lastValue, next }) => {
 				const optionResult = await option.execute(lastValue.restArgs, error);
-				if (optionResult === SymbolCommandError) return exit(SymbolCommandError);
+				if (optionResult === SymbolCommandError) return next(DObject.override(lastValue, { hasError: true }));
 				return next({
 					options: DObject.override(lastValue.options, { [option.name]: optionResult.result }),
-					restArgs: optionResult.argumentRest
+					restArgs: optionResult.argumentRest,
+					hasError: lastValue.hasError
 				});
 			});
-			if (commandOptions === SymbolCommandError) return SymbolCommandError;
+			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 commandArguments = await DGenerator.asyncReduce(self.subject.args, DGenerator.reduceFrom({
+				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 }) => {
@@ -70,13 +75,16 @@ function create(...args) {
 						restArgs: DArray.shift(lastValue.restArgs)
 					});
 				});
-				if (commandArguments === SymbolCommandError) return SymbolCommandError;
+				if (commandArgs === SymbolCommandError) return SymbolCommandError;
 				await execute({
 					options: commandOptions.options,
-					args: commandArguments.args
+					args: commandArgs.args
 				});
 			} else {
-				if (commandOptions.restArgs.length > 0) return error.addTooMuchCommandArgumentIssue(0, commandOptions.restArgs.length);
+				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 });
 			}
 		},

package/dist/command/error.cjs

@@ -2,12 +2,12 @@ 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_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");
@@ -23,6 +23,20 @@ function createError(commandName) {
 		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,
@@ -84,63 +98,102 @@ function createError(commandName) {
 	};
 }
 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),
+	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({
-		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}`]
+		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.render([
+	return _duplojs_lang_printer.renderParagraph([
 		_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)]);
+		_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"),
-		_duplojs_lang_printer.back,
+		["", ""],
 		interpretErrorIssues(error.issues, dataStructureErrorInterpreter ?? defaultDataStructureErrorInterpreter)
 	]);
 }

package/dist/command/error.d.ts

@@ -27,17 +27,25 @@ export interface DataStructureArgumentIssue extends ArgumentIssueBase, DModeling
 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);
+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;

package/dist/command/error.mjs

@@ -1,8 +1,8 @@
 import { defaultErrorInterpreterCodecDictionary, defaultErrorInterpreterDataStructureDictionary } from "../dataStructure/common/error/defaultInterpreter.mjs";
 import * as DCommon from "@duplojs/lang/common";
+import * as DPattern from "@duplojs/lang/pattern";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 import * as DArray from "@duplojs/lang/array";
-import * as DPattern from "@duplojs/lang/pattern";
 import * as DString from "@duplojs/lang/string";
 import * as DPrinter from "@duplojs/lang/printer";
 import * as DModeling from "@duplojs/lang/modeling";
@@ -15,6 +15,20 @@ function createError(commandName) {
 		issues,
 		currentPath,
 		pushPath: (path) => void currentPath.push(path),
+		addUnknownOptionIssue: (optionTokens) => {
+			issues.push(DModeling.taggedObject("UnknownOptionIssue", {
+				optionTokens,
+				path: DString.join(currentPath, ".")
+			}));
+			return SymbolCommandError;
+		},
+		addUnknownSubCommandIssue: (subCommandName) => {
+			issues.push(DModeling.taggedObject("UnknownSubCommandIssue", {
+				subCommandName,
+				path: DString.join(currentPath, ".")
+			}));
+			return SymbolCommandError;
+		},
 		addRequiredOptionIssue: (optionName) => {
 			issues.push(DModeling.taggedObject("RequiredOptionIssue", {
 				optionName,
@@ -76,63 +90,102 @@ function createError(commandName) {
 	};
 }
 function interpretDataStructureError(error, dataStructureErrorInterpreter) {
-	return DCommon.pipe(dataStructureErrorInterpreter(error), DArray.map(({ interpretedMessage, path }) => DPrinter.render([
-		DPrinter.indent(1),
+	return DCommon.pipe(dataStructureErrorInterpreter(error), DArray.map(({ interpretedMessage, path }) => DPrinter.renderLine([
 		"↳ ",
 		DPrinter.colorizedBold(path || "<value>", "cyan"),
 		" : ",
 		DPrinter.colorizedBold(interpretedMessage.subSource ?? interpretedMessage.interpretedSubSource ?? interpretedMessage.source ?? interpretedMessage.interpretedSource ?? "unknown data structure error.", "red")
-	], "")));
+	], {
+		joinCharacter: "",
+		indent: DPrinter.Indent.tab,
+		indentLevel: 1
+	})));
 }
 function interpretErrorIssues(issues, dataStructureErrorInterpreter) {
 	return DPrinter.renderParagraph([DArray.map(issues, DPattern.matchWithTaggedObject({
-		DataStructureArgumentIssue: ({ argumentName, dataStructureError }) => [DPrinter.render([
-			DPrinter.indent(1),
-			DPrinter.colorizedBold("ARGUMENT: ", "magenta"),
-			`--${argumentName}`
-		], ""), interpretDataStructureError(dataStructureError, dataStructureErrorInterpreter)],
-		RequiredArgumentIssue: ({ argumentName }) => [DPrinter.render([
-			DPrinter.indent(1),
-			DPrinter.colorizedBold("ARGUMENT: ", "magenta"),
-			argumentName
-		], ""), `${DPrinter.indent(1)}↳ Missing Argument`],
-		DataStructureOptionIssue: ({ optionName, dataStructureError }) => [DPrinter.render([
-			DPrinter.indent(1),
-			DPrinter.colorizedBold("OPTION: ", "blue"),
-			`--${optionName}`
-		], ""), interpretDataStructureError(dataStructureError, dataStructureErrorInterpreter)],
-		RequiredOptionIssue: ({ optionName }) => [DPrinter.render([
-			DPrinter.indent(1),
-			DPrinter.colorizedBold("OPTION: ", "blue"),
-			`--${optionName}`
-		], ""), `${DPrinter.indent(1)}↳ Missing Option`],
-		RequiredOptionValueIssue: ({ optionName }) => [DPrinter.render([
-			DPrinter.indent(1),
-			DPrinter.colorizedBold("OPTION: ", "blue"),
-			`--${optionName}`
-		], ""), `${DPrinter.indent(1)}↳ Missing Option Value`],
-		UnexpectedOptionValueIssue: ({ optionName }) => [DPrinter.render([
-			DPrinter.indent(1),
-			DPrinter.colorizedBold("OPTION: ", "blue"),
-			`--${optionName}`
-		], ""), `${DPrinter.indent(1)}↳ Unexpected Value At This Option`],
-		TooMuchCommandArgumentIssue: ({ expect, receive }) => [`${DPrinter.indent(1)} Too Much Arguments`, `${DPrinter.indent(1)} expect: ${expect} receive: ${receive}`]
+		UnknownOptionIssue: ({ optionTokens }) => [DPrinter.renderLine([DPrinter.colorizedBold("OPTION: ", "blue"), DString.join(optionTokens, ", ")], {
+			joinCharacter: "",
+			indent: DPrinter.Indent.tab,
+			indentLevel: 1
+		}), DPrinter.renderLine(["↳ Unknown Option"], {
+			indent: DPrinter.Indent.tab,
+			indentLevel: 1
+		})],
+		UnknownSubCommandIssue: ({ subCommandName }) => [DPrinter.renderLine([DPrinter.colorizedBold("SUB-COMMAND: ", "cyan"), subCommandName], {
+			joinCharacter: "",
+			indent: DPrinter.Indent.tab,
+			indentLevel: 1
+		}), DPrinter.renderLine(["↳ Unknown Sub-command"], {
+			indent: DPrinter.Indent.tab,
+			indentLevel: 1
+		})],
+		DataStructureArgumentIssue: ({ argumentName, dataStructureError }) => [DPrinter.renderLine([DPrinter.colorizedBold("ARGUMENT: ", "magenta"), `--${argumentName}`], {
+			joinCharacter: "",
+			indent: DPrinter.Indent.tab,
+			indentLevel: 1
+		}), interpretDataStructureError(dataStructureError, dataStructureErrorInterpreter)],
+		RequiredArgumentIssue: ({ argumentName }) => [DPrinter.renderLine([DPrinter.colorizedBold("ARGUMENT: ", "magenta"), argumentName], {
+			joinCharacter: "",
+			indent: DPrinter.Indent.tab,
+			indentLevel: 1
+		}), DPrinter.renderLine(["↳ Missing Argument"], {
+			indent: DPrinter.Indent.tab,
+			indentLevel: 1
+		})],
+		DataStructureOptionIssue: ({ optionName, dataStructureError }) => [DPrinter.renderLine([DPrinter.colorizedBold("OPTION: ", "blue"), `--${optionName}`], {
+			joinCharacter: "",
+			indent: DPrinter.Indent.tab,
+			indentLevel: 1
+		}), interpretDataStructureError(dataStructureError, dataStructureErrorInterpreter)],
+		RequiredOptionIssue: ({ optionName }) => [DPrinter.renderLine([DPrinter.colorizedBold("OPTION: ", "blue"), `--${optionName}`], {
+			joinCharacter: "",
+			indent: DPrinter.Indent.tab,
+			indentLevel: 1
+		}), DPrinter.renderLine(["↳ Missing Option"], {
+			indent: DPrinter.Indent.tab,
+			indentLevel: 1
+		})],
+		RequiredOptionValueIssue: ({ optionName }) => [DPrinter.renderLine([DPrinter.colorizedBold("OPTION: ", "blue"), `--${optionName}`], {
+			joinCharacter: "",
+			indent: DPrinter.Indent.tab,
+			indentLevel: 1
+		}), DPrinter.renderLine(["↳ Missing Option Value"], {
+			indent: DPrinter.Indent.tab,
+			indentLevel: 1
+		})],
+		UnexpectedOptionValueIssue: ({ optionName }) => [DPrinter.renderLine([DPrinter.colorizedBold("OPTION: ", "blue"), `--${optionName}`], {
+			joinCharacter: "",
+			indent: DPrinter.Indent.tab,
+			indentLevel: 1
+		}), DPrinter.renderLine(["↳ Unexpected Value At This Option"], {
+			indent: DPrinter.Indent.tab,
+			indentLevel: 1
+		})],
+		TooMuchCommandArgumentIssue: ({ expect, receive }) => [DPrinter.renderLine([" Too Much Arguments"], {
+			indent: DPrinter.Indent.tab,
+			indentLevel: 1
+		}), DPrinter.renderLine([` expect: ${expect} receive: ${receive}`], {
+			indent: DPrinter.Indent.tab,
+			indentLevel: 1
+		})]
 	})), issues.length === 0 && "No issue found"]);
 }
 const defaultDataStructureErrorInterpreter = DDataStructure.createErrorInterpreter(defaultErrorInterpreterDataStructureDictionary, defaultErrorInterpreterCodecDictionary);
 function interpretExecCommandError(error, dataStructureErrorInterpreter) {
-	return DPrinter.renderParagraph([DPrinter.render([
+	return DPrinter.renderParagraph([
 		DPrinter.colorizedBold("Command failed", "red"),
-		DPrinter.back,
-		DPrinter.indent(1),
-		DPrinter.colorizedBold("COMMAND: ", "cyan"),
-		DString.join(error.currentPath, " ")
-	], ""), interpretErrorIssues(error.issues, dataStructureErrorInterpreter ?? defaultDataStructureErrorInterpreter)]);
+		DPrinter.renderLine([DPrinter.colorizedBold("COMMAND: ", "cyan"), DString.join(error.currentPath, " ")], {
+			joinCharacter: "",
+			indent: DPrinter.Indent.tab,
+			indentLevel: 1
+		}),
+		interpretErrorIssues(error.issues, dataStructureErrorInterpreter ?? defaultDataStructureErrorInterpreter)
+	]);
 }
 function interpretExecOptionsError(error, dataStructureErrorInterpreter) {
 	return DPrinter.renderParagraph([
 		DPrinter.colorizedBold("Invalid options", "red"),
-		DPrinter.back,
+		["", ""],
 		interpretErrorIssues(error.issues, dataStructureErrorInterpreter ?? defaultDataStructureErrorInterpreter)
 	]);
 }

package/dist/command/exec.d.ts

@@ -2,12 +2,13 @@ import { CreateCommandExecuteParams, CreateCommandParams, Subjects } from './cre
 import { Error } from './error';
 import { Option } from './options';
 import { Argument } from './argument';
+import { ForbiddenInvalidIdentifier } from './types';
 import type * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import type * as DDataStructure from "@duplojs/lang/dataStructure";
-export interface ExecCommandParams<GenericOptions extends DCommon.AnyTuple<Option> = DCommon.AnyTuple<Option>, GenericSubjects extends Subjects = Subjects> extends CreateCommandParams<GenericOptions, GenericSubjects> {
-    displayName?: string;
+export interface ExecCommandParams<GenericOptions extends DCommon.AnyTuple<Option> = DCommon.AnyTuple<Option>, GenericSubjects extends Subjects = Subjects, GenericDisplayName extends string = string> extends CreateCommandParams<GenericOptions, GenericSubjects> {
+    displayName?: GenericDisplayName & ForbiddenInvalidIdentifier<GenericDisplayName>;
     dataStructureErrorInterpreter?: DDataStructure.ErrorInterpreter;
 }
 export declare function exec(execute: () => void): Promise<DEither.Ok | DEither.Error<Error>>;
-export declare function exec<const GenericOptions extends DCommon.AnyTuple<Option> = never, GenericSubjects extends Subjects = never>(params: ExecCommandParams<GenericOptions, GenericSubjects>, execute: (params: CreateCommandExecuteParams<GenericOptions, Extract<GenericSubjects, DCommon.AnyTuple<Argument>>>) => DCommon.MaybePromise<void>): Promise<DEither.Ok | DEither.Error<Error>>;
+export declare function exec<const GenericOptions extends DCommon.AnyTuple<Option> = never, GenericSubjects extends Subjects = never, const GenericDisplayName extends string = string>(params: ExecCommandParams<GenericOptions, GenericSubjects, GenericDisplayName>, execute: (params: CreateCommandExecuteParams<GenericOptions, Extract<GenericSubjects, DCommon.AnyTuple<Argument>>>) => DCommon.MaybePromise<void>): Promise<DEither.Ok | DEither.Error<Error>>;