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

package/dist/command/error.mjs

@@ -0,0 +1,140 @@
+import { defaultErrorInterpreterCodecDictionary, defaultErrorInterpreterDataStructureDictionary } from "../dataStructure/common/error/defaultInterpreter.mjs";
+import * as DCommon from "@duplojs/lang/common";
+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";
+//#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(DModeling.taggedObject("RequiredOptionIssue", {
+				optionName,
+				data: void 0,
+				path: currentPath.join(".")
+			}));
+			return SymbolCommandError;
+		},
+		addRequiredOptionValueIssue: (optionName) => {
+			issues.push(DModeling.taggedObject("RequiredOptionValueIssue", {
+				optionName,
+				data: void 0,
+				path: currentPath.join(".")
+			}));
+			return SymbolCommandError;
+		},
+		addUnexpectedOptionValueIssue: (optionName, data) => {
+			issues.push(DModeling.taggedObject("UnexpectedOptionValueIssue", {
+				optionName,
+				data,
+				path: currentPath.join(".")
+			}));
+			return SymbolCommandError;
+		},
+		addDataStructureOptionIssue: (optionName, data, dataStructureError) => {
+			issues.push(DModeling.taggedObject("DataStructureOptionIssue", {
+				optionName,
+				data,
+				dataStructureError,
+				path: currentPath.join(".")
+			}));
+			return SymbolCommandError;
+		},
+		addRequiredArgumentIssue: (argumentName) => {
+			issues.push(DModeling.taggedObject("RequiredArgumentIssue", {
+				argumentName,
+				data: void 0,
+				path: currentPath.join(".")
+			}));
+			return SymbolCommandError;
+		},
+		addDataStructureArgumentIssue: (argumentName, data, dataStructureError) => {
+			issues.push(DModeling.taggedObject("DataStructureArgumentIssue", {
+				argumentName,
+				data,
+				dataStructureError,
+				path: currentPath.join(".")
+			}));
+			return SymbolCommandError;
+		},
+		addTooMuchCommandArgumentIssue: (expect, receive) => {
+			issues.push(DModeling.taggedObject("TooMuchCommandArgumentIssue", {
+				expect,
+				receive,
+				path: currentPath.join(".")
+			}));
+			return SymbolCommandError;
+		}
+	};
+}
+function interpretDataStructureError(error, dataStructureErrorInterpreter) {
+	return DCommon.pipe(dataStructureErrorInterpreter(error), DArray.map(({ interpretedMessage, path }) => DPrinter.render([
+		DPrinter.indent(1),
+		"↳ ",
+		DPrinter.colorizedBold(path || "<value>", "cyan"),
+		" : ",
+		DPrinter.colorizedBold(interpretedMessage.subSource ?? interpretedMessage.interpretedSubSource ?? interpretedMessage.source ?? interpretedMessage.interpretedSource ?? "unknown data structure error.", "red")
+	], "")));
+}
+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}`]
+	})), issues.length === 0 && "No issue found"]);
+}
+const defaultDataStructureErrorInterpreter = DDataStructure.createErrorInterpreter(defaultErrorInterpreterDataStructureDictionary, defaultErrorInterpreterCodecDictionary);
+function interpretExecCommandError(error, dataStructureErrorInterpreter) {
+	return DPrinter.renderParagraph([DPrinter.render([
+		DPrinter.colorizedBold("Command failed", "red"),
+		DPrinter.back,
+		DPrinter.indent(1),
+		DPrinter.colorizedBold("COMMAND: ", "cyan"),
+		DString.join(error.currentPath, " ")
+	], ""), interpretErrorIssues(error.issues, dataStructureErrorInterpreter ?? defaultDataStructureErrorInterpreter)]);
+}
+function interpretExecOptionsError(error, dataStructureErrorInterpreter) {
+	return DPrinter.renderParagraph([
+		DPrinter.colorizedBold("Invalid options", "red"),
+		DPrinter.back,
+		interpretErrorIssues(error.issues, dataStructureErrorInterpreter ?? defaultDataStructureErrorInterpreter)
+	]);
+}
+//#endregion
+export { SymbolCommandError, createError, interpretDataStructureError, interpretErrorIssues, interpretExecCommandError, interpretExecOptionsError };

package/dist/command/exec.cjs

@@ -0,0 +1,19 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_getProcessArguments = require("../common/getProcessArguments.cjs");
+const require_error = require("./error.cjs");
+const require_create = require("./create.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+//#region scripts/command/exec.ts
+async function exec(...args) {
+	const [params, execute] = args.length === 1 ? [{}, args[0]] : args;
+	const displayName = params.displayName ?? "root";
+	const error = require_error.createError(displayName);
+	if (await require_create.create(displayName, params, execute).execute(require_getProcessArguments.getProcessArguments(), error) === require_error.SymbolCommandError) {
+		console.error(require_error.interpretExecCommandError(error, params?.dataStructureErrorInterpreter));
+		return _duplojs_lang_either.error(error);
+	}
+	return _duplojs_lang_either.ok();
+}
+//#endregion
+exports.exec = exec;

package/dist/command/exec.d.ts

@@ -0,0 +1,13 @@
+import { CreateCommandExecuteParams, CreateCommandParams, Subjects } from './create';
+import { Error } from './error';
+import { Option } from './options';
+import { Argument } from './argument';
+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;
+    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>>;

package/dist/command/exec.mjs

@@ -0,0 +1,17 @@
+import { getProcessArguments } from "../common/getProcessArguments.mjs";
+import { SymbolCommandError, createError, interpretExecCommandError } from "./error.mjs";
+import { create } from "./create.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/command/exec.ts
+async function exec(...args) {
+	const [params, execute] = args.length === 1 ? [{}, args[0]] : args;
+	const displayName = params.displayName ?? "root";
+	const error = createError(displayName);
+	if (await create(displayName, params, execute).execute(getProcessArguments(), error) === SymbolCommandError) {
+		console.error(interpretExecCommandError(error, params?.dataStructureErrorInterpreter));
+		return DEither.error(error);
+	}
+	return DEither.ok();
+}
+//#endregion
+export { exec };

package/dist/command/execOptions.cjs

@@ -0,0 +1,41 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_getProcessArguments = require("../common/getProcessArguments.cjs");
+const require_error = require("./error.cjs");
+const require_help = require("./help.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_object = require("@duplojs/lang/object");
+_duplojs_lang_object = require_runtime.__toESM(_duplojs_lang_object, 1);
+let _duplojs_lang_generator = require("@duplojs/lang/generator");
+_duplojs_lang_generator = require_runtime.__toESM(_duplojs_lang_generator, 1);
+//#region scripts/command/execOptions.ts
+async function execOptions(options, params) {
+	const processArguments = require_getProcessArguments.getProcessArguments();
+	const error = require_error.createError("root");
+	const help = await require_help.helpOption.execute(processArguments, error);
+	if (help === require_error.SymbolCommandError) {
+		console.error(require_error.interpretExecOptionsError(error, params?.dataStructureErrorInterpreter));
+		return _duplojs_lang_either.error(error);
+	} else if (help.result) {
+		require_help.logExecOptionHelp(options);
+		return _duplojs_lang_either.right("log-help");
+	}
+	const result = await _duplojs_lang_generator.asyncReduce(options, _duplojs_lang_generator.reduceFrom({
+		options: {},
+		restArgs: processArguments
+	}), 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 (result === require_error.SymbolCommandError) {
+		console.error(require_error.interpretExecOptionsError(error, params?.dataStructureErrorInterpreter));
+		return _duplojs_lang_either.error(error);
+	}
+	return _duplojs_lang_either.success(result.options);
+}
+//#endregion
+exports.execOptions = execOptions;

package/dist/command/execOptions.d.ts

@@ -0,0 +1,14 @@
+import { Error } from './error';
+import { Option } from './options';
+import { ForbiddenDuplicateName } 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";
+type ComputeResult<GenericOptions extends DCommon.AnyTuple<Option>> = DCommon.SimplifyTopLevel<{
+    readonly [GenericOption in GenericOptions[number] as GenericOption extends Option<infer GenericName, unknown> ? GenericName : never]: GenericOption extends Option<string, infer GenericResult> ? GenericResult : never;
+}>;
+export interface ExecOptionsParams {
+    dataStructureErrorInterpreter?: DDataStructure.ErrorInterpreter;
+}
+export declare function execOptions<GenericOptions extends DCommon.AnyTuple<Option>>(options: GenericOptions & ForbiddenDuplicateName<GenericOptions, "option">, params?: ExecOptionsParams): Promise<DEither.Success<Extract<ComputeResult<GenericOptions>, any>> | DEither.Right<"log-help"> | DEither.Error<Error>>;
+export {};

package/dist/command/execOptions.mjs

@@ -0,0 +1,37 @@
+import { getProcessArguments } from "../common/getProcessArguments.mjs";
+import { SymbolCommandError, createError, interpretExecOptionsError } from "./error.mjs";
+import { helpOption, logExecOptionHelp } from "./help.mjs";
+import * as DEither from "@duplojs/lang/either";
+import * as DObject from "@duplojs/lang/object";
+import * as DGenerator from "@duplojs/lang/generator";
+//#region scripts/command/execOptions.ts
+async function execOptions(options, params) {
+	const processArguments = getProcessArguments();
+	const error = createError("root");
+	const help = await helpOption.execute(processArguments, error);
+	if (help === SymbolCommandError) {
+		console.error(interpretExecOptionsError(error, params?.dataStructureErrorInterpreter));
+		return DEither.error(error);
+	} else if (help.result) {
+		logExecOptionHelp(options);
+		return DEither.right("log-help");
+	}
+	const result = await DGenerator.asyncReduce(options, DGenerator.reduceFrom({
+		options: {},
+		restArgs: processArguments
+	}), 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 (result === SymbolCommandError) {
+		console.error(interpretExecOptionsError(error, params?.dataStructureErrorInterpreter));
+		return DEither.error(error);
+	}
+	return DEither.success(result.options);
+}
+//#endregion
+export { execOptions };

package/dist/command/help.cjs

@@ -0,0 +1,257 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_exist = require("../dataStructure/constraint/exist.cjs");
+const require_mimeType = require("../dataStructure/constraint/mimeType.cjs");
+const require_size = require("../dataStructure/constraint/size.cjs");
+const require_file = require("../dataStructure/type/file.cjs");
+const require_array = require("./options/defaults/array.cjs");
+const require_boolean = require("./options/defaults/boolean.cjs");
+const require_simple = require("./options/defaults/simple.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);
+//#region scripts/command/help.ts
+const helpOption = require_boolean.createBooleanOption("help", { aliases: ["h"] });
+const syntax = (input) => _duplojs_lang_printer.colorized(input, "gray");
+const section = (input, color) => _duplojs_lang_printer.colorizedBold(input, color);
+const name = (input) => _duplojs_lang_printer.colorizedBold(input, "cyan");
+const typeLabel = (input) => _duplojs_lang_printer.colorized(input, "blue");
+const literal = (input) => _duplojs_lang_printer.colorized(input, "yellow");
+const marker = (input) => _duplojs_lang_printer.colorized(input, "yellow");
+const secondary = (input) => _duplojs_lang_printer.colorized(input, "gray");
+const constraintLabel = (input) => _duplojs_lang_printer.colorized(input, "magenta");
+function renderInline(input) {
+	return _duplojs_lang_printer.render(input, "");
+}
+function formatLiteral(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "bigint") return `${value.toString()}n`;
+	return String(value);
+}
+function formatBytes(value) {
+	const units = [
+		"B",
+		"KB",
+		"MB",
+		"GB",
+		"TB"
+	];
+	let size = value;
+	let index = 0;
+	while (size >= 1024 && index < units.length - 1) {
+		size = size / 1024;
+		index++;
+	}
+	return `${Number.isInteger(size) ? size : size.toFixed(1)} ${units[index]}`;
+}
+function renderType(type) {
+	return _duplojs_lang_pattern.match(type).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.stringLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.numberLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.bigintLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.booleanLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.nullTypeKind), _duplojs_lang_common.justReturn([literal("null")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.undefinedTypeKind), _duplojs_lang_common.justReturn([literal("undefined")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.stringTypeKind), _duplojs_lang_common.justReturn([typeLabel("string")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.numberTypeKind), _duplojs_lang_common.justReturn([typeLabel("number")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.bigintTypeKind), _duplojs_lang_common.justReturn([typeLabel("bigint")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.booleanTypeKind), _duplojs_lang_common.justReturn([typeLabel("boolean")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.dateTypeKind), _duplojs_lang_common.justReturn([typeLabel("date")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.timeTypeKind), _duplojs_lang_common.justReturn([typeLabel("time")])).when(_duplojs_lang_dataStructure.typeIdentifier(require_file.fileTypeKind), _duplojs_lang_common.justReturn([typeLabel("file")])).otherwise(_duplojs_lang_common.justReturn([typeLabel("unknown")]));
+}
+function renderStringLength(constraints) {
+	const equal = _duplojs_lang_array.find(constraints, _duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.stringLengthEqualConstraintKind));
+	const min = _duplojs_lang_array.find(constraints, _duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.minCharactersConstraintKind));
+	const max = _duplojs_lang_array.find(constraints, _duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.maxCharactersConstraintKind));
+	if (equal) return [constraintLabel("length "), literal(String(equal.definition.length))];
+	if (min && max) return [constraintLabel("length "), literal(`${min.definition.min}..${max.definition.max}`)];
+	if (min) return [constraintLabel("min length "), literal(String(min.definition.min))];
+	if (max) return [constraintLabel("max length "), literal(String(max.definition.max))];
+	return null;
+}
+function renderArrayLength(constraints) {
+	const equal = _duplojs_lang_array.find(constraints, _duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.arrayLengthEqualConstraintKind));
+	const min = _duplojs_lang_array.find(constraints, _duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.minElementsConstraintKind));
+	const max = _duplojs_lang_array.find(constraints, _duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.maxElementsConstraintKind));
+	if (equal) return [constraintLabel("items "), literal(String(equal.definition.length))];
+	if (min && max) return [constraintLabel("items "), literal(`${min.definition.min}..${max.definition.max}`)];
+	if (min) return [constraintLabel("min items "), literal(String(min.definition.min))];
+	if (max) return [constraintLabel("max items "), literal(String(max.definition.max))];
+	return null;
+}
+function renderNumberBounds(constraints) {
+	const greaterThan = _duplojs_lang_array.find(constraints, _duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.greaterThanConstraintKind));
+	const greaterThanOrEqual = _duplojs_lang_array.find(constraints, _duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.greaterThanOrEqualConstraintKind));
+	const lessThan = _duplojs_lang_array.find(constraints, _duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.lessThanConstraintKind));
+	const lessThanOrEqual = _duplojs_lang_array.find(constraints, _duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.lessThanOrEqualConstraintKind));
+	return _duplojs_lang_array.filter([greaterThan ? [constraintLabel("> "), literal(String(greaterThan.definition.threshold))] : greaterThanOrEqual ? [constraintLabel("min "), literal(String(greaterThanOrEqual.definition.threshold))] : null, lessThan ? [constraintLabel("< "), literal(String(lessThan.definition.threshold))] : lessThanOrEqual ? [constraintLabel("max "), literal(String(lessThanOrEqual.definition.threshold))] : null], _duplojs_lang_common.truthy);
+}
+function renderSimpleConstraint(constraint) {
+	return _duplojs_lang_pattern.match(constraint).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.emailConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("email")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.urlConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("url")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.uuidConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("uuid")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.integerConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("integer")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.trimmedConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("trimmed")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.notEmptyConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("not empty")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.numberInStringConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("number in string")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.evenConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("even")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.oddConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("odd")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.positiveConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("positive")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.negativeConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("negative")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.notZeroConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("not zero")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.safeConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("safe number")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.pathConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("path")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.absolutePathConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("absolute path")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.segmentPathConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("path segment")])).when(_duplojs_lang_dataStructure.constraintIdentifier(require_exist.existConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("exists")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.strictPositiveConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("> "), literal("0")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.strictNegativeConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("< "), literal("0")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.betweenThanConstraintKind), ({ definition }) => [
+		constraintLabel("> "),
+		literal(String(definition.greater)),
+		secondary(" and "),
+		constraintLabel("< "),
+		literal(String(definition.less))
+	]).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.betweenThanOrEqualConstraintKind), ({ definition }) => [constraintLabel("range "), literal(`${definition.greater}..${definition.less}`)]).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.multipleOfConstraintKind), ({ definition }) => [constraintLabel("multiple of "), literal(String(definition.multiple))]).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.regexConstraintKind), ({ definition }) => [constraintLabel("pattern "), literal(definition.regex.toString())]).when(_duplojs_lang_dataStructure.constraintIdentifier(require_mimeType.mimeTypeConstraintKind), ({ definition }) => [constraintLabel("mime "), literal(definition.regex.toString())]).when(_duplojs_lang_dataStructure.constraintIdentifier(require_size.sizeConstraintKind), (constraint) => {
+		const { min, max } = constraint.definition;
+		if (min && max) return [constraintLabel("size "), literal(`${formatBytes(min)}..${formatBytes(max)}`)];
+		if (min) return [constraintLabel("min size "), literal(formatBytes(min))];
+		if (max) return [constraintLabel("max size "), literal(formatBytes(max))];
+		return null;
+	}).otherwise(_duplojs_lang_common.justReturn(null));
+}
+function renderConstraints(constraints) {
+	return _duplojs_lang_array.filter([
+		renderStringLength(constraints),
+		renderArrayLength(constraints),
+		...renderNumberBounds(constraints),
+		..._duplojs_lang_array.map(constraints, renderSimpleConstraint)
+	], _duplojs_lang_common.truthy);
+}
+function renderDataStructure(dataStructure) {
+	const constraints = renderConstraints(dataStructure.definition.constraints);
+	if (_duplojs_lang_dataStructure.structureIdentifier(dataStructure, _duplojs_lang_dataStructure.lazyStructureKind)) {
+		const inner = renderDataStructure(dataStructure.definition.getter.value);
+		return {
+			main: inner.main,
+			constraints: [...inner.constraints, ...constraints]
+		};
+	}
+	if (_duplojs_lang_dataStructure.structureIdentifier(dataStructure, _duplojs_lang_dataStructure.typeStructureKind)) return {
+		main: renderType(dataStructure.definition.type),
+		constraints
+	};
+	if (_duplojs_lang_dataStructure.structureIdentifier(dataStructure, _duplojs_lang_dataStructure.arrayStructureKind)) {
+		const element = renderDataStructure(dataStructure.definition.element);
+		return {
+			main: [...element.main, typeLabel("[]")],
+			constraints: [..._duplojs_lang_array.map(element.constraints, (constraint) => [constraintLabel("item "), constraint]), ...constraints]
+		};
+	}
+	if (_duplojs_lang_dataStructure.structureIdentifier(dataStructure, _duplojs_lang_dataStructure.unionStructureKind)) {
+		const values = _duplojs_lang_common.pipe(dataStructure.definition.values.value, _duplojs_lang_array.filter((structure) => !_duplojs_lang_dataStructure.isUndefinedStructure(structure)), _duplojs_lang_array.map(renderDataStructure));
+		if (values.length === 0) return {
+			main: [literal("undefined")],
+			constraints
+		};
+		if (values.length === 1) return {
+			main: values[0].main,
+			constraints: [...values[0].constraints, ...constraints]
+		};
+		return {
+			main: _duplojs_lang_array.reduce(_duplojs_lang_array.map(values, ({ main }) => main), _duplojs_lang_array.reduceFrom([]), ({ element, index, lastValue, next }) => next([
+				...lastValue,
+				index === 0 ? null : [secondary(" | ")],
+				element
+			])),
+			constraints
+		};
+	}
+	return {
+		main: [typeLabel("unknown")],
+		constraints
+	};
+}
+function renderMetadata(help, markerValue) {
+	return renderInline([
+		...help.main,
+		secondary(" · "),
+		markerValue === "required" ? marker(markerValue) : secondary(markerValue)
+	]);
+}
+function renderConstraintLines(constraints, depth) {
+	return _duplojs_lang_array.map(constraints, (constraint) => renderInline([
+		_duplojs_lang_printer.indent(depth),
+		secondary("↳ "),
+		constraint
+	]));
+}
+function renderDescriptionLine(description, depth) {
+	return description ? renderInline([_duplojs_lang_printer.indent(depth), secondary(description)]) : null;
+}
+function renderUsage(command) {
+	const args = command.subject?.type === "argument" ? _duplojs_lang_array.map(command.subject.args, (argument) => argument.optional ? `[${argument.name}]` : `<${argument.name}>`) : command.subject?.type === "subCommand" ? ["<command>"] : [];
+	return _duplojs_lang_common.pipe([
+		command.name,
+		...args,
+		command.options.length > 0 ? "[options]" : null
+	], _duplojs_lang_array.filter(_duplojs_lang_common.truthy), _duplojs_lang_string.join(" "));
+}
+function renderOptionSignature(option) {
+	return [
+		_duplojs_lang_array.map(option.aliases, (alias) => [
+			syntax("-"),
+			name(alias),
+			syntax(", ")
+		]),
+		syntax("--"),
+		name(option.name),
+		require_simple.simpleOptionKind.has(option) ? syntax(" <value>") : null,
+		require_array.arrayOptionKind.has(option) ? syntax(" <value...>") : null
+	];
+}
+function renderOptionDetails(option, depth) {
+	if (require_simple.simpleOptionKind.has(option) || require_array.arrayOptionKind.has(option)) {
+		const help = renderDataStructure(option.dataStructure);
+		return _duplojs_lang_array.filter([
+			renderInline([_duplojs_lang_printer.indent(depth), renderMetadata(help, option.required ? "required" : "optional")]),
+			renderDescriptionLine(option.description, depth),
+			...renderConstraintLines(help.constraints, depth)
+		], _duplojs_lang_common.truthy);
+	}
+	if (require_boolean.booleanOptionKind.has(option)) return _duplojs_lang_array.filter([renderInline([_duplojs_lang_printer.indent(depth), typeLabel("boolean")]), renderDescriptionLine(option.description, depth)], _duplojs_lang_common.truthy);
+	return _duplojs_lang_array.filter([renderDescriptionLine(option.description, depth)], _duplojs_lang_common.truthy);
+}
+function renderOptionsHelp(options, depth) {
+	return _duplojs_lang_printer.renderParagraph([renderInline([_duplojs_lang_printer.indent(depth), section("OPTIONS", "magenta")]), _duplojs_lang_array.map(options, (option) => _duplojs_lang_printer.renderParagraph([renderInline([_duplojs_lang_printer.indent(depth + 1), renderOptionSignature(option)]), renderOptionDetails(option, depth + 2)]))]);
+}
+function renderArgumentsHelp(args, depth) {
+	return _duplojs_lang_printer.renderParagraph([renderInline([_duplojs_lang_printer.indent(depth), section("ARGUMENTS", "cyan")]), _duplojs_lang_array.map(args, (argument) => {
+		const help = renderDataStructure(argument.dataStructure);
+		return _duplojs_lang_printer.renderParagraph([
+			renderInline([
+				_duplojs_lang_printer.indent(depth + 1),
+				name(argument.name.padEnd(12)),
+				renderMetadata(help, argument.optional ? "optional" : "required")
+			]),
+			renderDescriptionLine(argument.description, depth + 2),
+			renderConstraintLines(help.constraints, depth + 2)
+		]);
+	})]);
+}
+function renderSubCommandsHelp(commands, depth) {
+	return _duplojs_lang_printer.renderParagraph([renderInline([_duplojs_lang_printer.indent(depth), section("COMMANDS", "green")]), _duplojs_lang_array.map(commands, (command) => renderInline([
+		_duplojs_lang_printer.indent(depth + 1),
+		name(command.name.padEnd(16)),
+		command.description ? secondary(command.description) : null
+	]))]);
+}
+function renderCommandHelp(command, depth) {
+	return [..._duplojs_lang_array.filter([
+		renderInline([
+			_duplojs_lang_printer.indent(depth),
+			section("COMMAND", "green"),
+			"  ",
+			_duplojs_lang_printer.colorizedBold(command.name, "cyan")
+		]),
+		renderDescriptionLine(command.description, depth + 1),
+		_duplojs_lang_printer.renderParagraph([renderInline([_duplojs_lang_printer.indent(depth), section("USAGE", "blue")]), renderInline([_duplojs_lang_printer.indent(depth + 1), syntax(renderUsage(command))])]),
+		command.subject?.type === "argument" ? renderArgumentsHelp(command.subject.args, depth) : null,
+		command.subject?.type === "subCommand" ? renderSubCommandsHelp(command.subject.subCommands, depth) : null,
+		_duplojs_lang_array.minElements(command.options, 1) ? renderOptionsHelp(command.options, depth) : null
+	], _duplojs_lang_common.truthy)];
+}
+function logCommandHelp(command) {
+	console.log(_duplojs_lang_printer.renderParagraph(renderCommandHelp(command, 0)));
+}
+function renderExecOptionHelp(options, depth) {
+	return [renderInline([_duplojs_lang_printer.indent(depth), section("EXEC OPTIONS", "green")]), renderOptionsHelp(options, depth)];
+}
+function logExecOptionHelp(options) {
+	console.log(_duplojs_lang_printer.renderParagraph(renderExecOptionHelp(options, 0)));
+}
+//#endregion
+exports.helpOption = helpOption;
+exports.logCommandHelp = logCommandHelp;
+exports.logExecOptionHelp = logExecOptionHelp;
+exports.renderArgumentsHelp = renderArgumentsHelp;
+exports.renderCommandHelp = renderCommandHelp;
+exports.renderExecOptionHelp = renderExecOptionHelp;
+exports.renderOptionsHelp = renderOptionsHelp;

package/dist/command/help.d.ts

@@ -0,0 +1,10 @@
+import { Command } from './create';
+import { Argument } from './argument';
+import { Options } from './options';
+export declare const helpOption: NoInfer<import('./options').BooleanOption<"help">>;
+export declare function renderOptionsHelp(options: readonly Options[], depth: number): string;
+export declare function renderArgumentsHelp(args: readonly Argument[], depth: number): string;
+export declare function renderCommandHelp(command: Command, depth: number): string[];
+export declare function logCommandHelp(command: Command): void;
+export declare function renderExecOptionHelp(options: readonly Options[], depth: number): string[];
+export declare function logExecOptionHelp(options: readonly Options[]): void;