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

package/dist/command/help.mjs

@@ -0,0 +1,237 @@
+import { fileExistConstraintKind } from "../dataStructure/constraint/fileExist.mjs";
+import { folderExistConstraintKind } from "../dataStructure/constraint/folderExist.mjs";
+import { mimeTypeConstraintKind } from "../dataStructure/constraint/mimeType.mjs";
+import { sizeConstraintKind } from "../dataStructure/constraint/size.mjs";
+import { fileTypeKind } from "../dataStructure/type/file.mjs";
+import { folderTypeKind } from "../dataStructure/type/folder.mjs";
+import { arrayOptionKind } from "./options/defaults/array.mjs";
+import { booleanOptionKind, createBooleanOption } from "./options/defaults/boolean.mjs";
+import { simpleOptionKind } from "./options/defaults/simple.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 DString from "@duplojs/lang/string";
+import * as DPrinter from "@duplojs/lang/printer";
+//#region scripts/command/help.ts
+const helpOption = createBooleanOption("help", { aliases: ["h"] });
+const syntax = (input) => DPrinter.colorized(input, "gray");
+const section = (input, color) => DPrinter.colorizedBold(input, color);
+const name = (input) => DPrinter.colorizedBold(input, "cyan");
+const typeLabel = (input) => DPrinter.colorized(input, "blue");
+const literal = (input) => DPrinter.colorized(input, "yellow");
+const marker = (input) => DPrinter.colorized(input, "yellow");
+const secondary = (input) => DPrinter.colorized(input, "gray");
+const constraintLabel = (input) => DPrinter.colorized(input, "magenta");
+function renderInline(input, depth = 0) {
+	return DPrinter.renderLine(input, {
+		joinCharacter: "",
+		indent: DPrinter.Indent.tab,
+		indentLevel: depth
+	});
+}
+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 DPattern.match(type).when(DDataStructure.typeIdentifier(DDataStructure.stringLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(DDataStructure.typeIdentifier(DDataStructure.numberLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(DDataStructure.typeIdentifier(DDataStructure.bigintLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(DDataStructure.typeIdentifier(DDataStructure.booleanLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(DDataStructure.typeIdentifier(DDataStructure.nullTypeKind), DCommon.justReturn([literal("null")])).when(DDataStructure.typeIdentifier(DDataStructure.undefinedTypeKind), DCommon.justReturn([literal("undefined")])).when(DDataStructure.typeIdentifier(DDataStructure.stringTypeKind), DCommon.justReturn([typeLabel("string")])).when(DDataStructure.typeIdentifier(DDataStructure.numberTypeKind), DCommon.justReturn([typeLabel("number")])).when(DDataStructure.typeIdentifier(DDataStructure.bigintTypeKind), DCommon.justReturn([typeLabel("bigint")])).when(DDataStructure.typeIdentifier(DDataStructure.booleanTypeKind), DCommon.justReturn([typeLabel("boolean")])).when(DDataStructure.typeIdentifier(DDataStructure.dateTypeKind), DCommon.justReturn([typeLabel("date")])).when(DDataStructure.typeIdentifier(DDataStructure.timeTypeKind), DCommon.justReturn([typeLabel("time")])).when(DDataStructure.typeIdentifier(fileTypeKind), DCommon.justReturn([typeLabel("file")])).when(DDataStructure.typeIdentifier(folderTypeKind), DCommon.justReturn([typeLabel("folder")])).otherwise(DCommon.justReturn([typeLabel("unknown")]));
+}
+function renderStringLength(constraints) {
+	const equal = DArray.find(constraints, DDataStructure.constraintIdentifier(DDataStructure.stringLengthEqualConstraintKind));
+	const min = DArray.find(constraints, DDataStructure.constraintIdentifier(DDataStructure.minCharactersConstraintKind));
+	const max = DArray.find(constraints, DDataStructure.constraintIdentifier(DDataStructure.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 = DArray.find(constraints, DDataStructure.constraintIdentifier(DDataStructure.arrayLengthEqualConstraintKind));
+	const min = DArray.find(constraints, DDataStructure.constraintIdentifier(DDataStructure.minElementsConstraintKind));
+	const max = DArray.find(constraints, DDataStructure.constraintIdentifier(DDataStructure.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 = DArray.find(constraints, DDataStructure.constraintIdentifier(DDataStructure.greaterThanConstraintKind));
+	const greaterThanOrEqual = DArray.find(constraints, DDataStructure.constraintIdentifier(DDataStructure.greaterThanOrEqualConstraintKind));
+	const lessThan = DArray.find(constraints, DDataStructure.constraintIdentifier(DDataStructure.lessThanConstraintKind));
+	const lessThanOrEqual = DArray.find(constraints, DDataStructure.constraintIdentifier(DDataStructure.lessThanOrEqualConstraintKind));
+	return DArray.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], DCommon.truthy);
+}
+function renderSimpleConstraint(constraint) {
+	return DPattern.match(constraint).when(DDataStructure.constraintIdentifier(DDataStructure.emailConstraintKind), DCommon.justReturn([constraintLabel("email")])).when(DDataStructure.constraintIdentifier(DDataStructure.urlConstraintKind), DCommon.justReturn([constraintLabel("url")])).when(DDataStructure.constraintIdentifier(DDataStructure.uuidConstraintKind), DCommon.justReturn([constraintLabel("uuid")])).when(DDataStructure.constraintIdentifier(DDataStructure.integerConstraintKind), DCommon.justReturn([constraintLabel("integer")])).when(DDataStructure.constraintIdentifier(DDataStructure.trimmedConstraintKind), DCommon.justReturn([constraintLabel("trimmed")])).when(DDataStructure.constraintIdentifier(DDataStructure.notEmptyConstraintKind), DCommon.justReturn([constraintLabel("not empty")])).when(DDataStructure.constraintIdentifier(DDataStructure.numberInStringConstraintKind), DCommon.justReturn([constraintLabel("number in string")])).when(DDataStructure.constraintIdentifier(DDataStructure.evenConstraintKind), DCommon.justReturn([constraintLabel("even")])).when(DDataStructure.constraintIdentifier(DDataStructure.oddConstraintKind), DCommon.justReturn([constraintLabel("odd")])).when(DDataStructure.constraintIdentifier(DDataStructure.positiveConstraintKind), DCommon.justReturn([constraintLabel("positive")])).when(DDataStructure.constraintIdentifier(DDataStructure.negativeConstraintKind), DCommon.justReturn([constraintLabel("negative")])).when(DDataStructure.constraintIdentifier(DDataStructure.notZeroConstraintKind), DCommon.justReturn([constraintLabel("not zero")])).when(DDataStructure.constraintIdentifier(DDataStructure.safeConstraintKind), DCommon.justReturn([constraintLabel("safe number")])).when(DDataStructure.constraintIdentifier(DDataStructure.pathConstraintKind), DCommon.justReturn([constraintLabel("path")])).when(DDataStructure.constraintIdentifier(DDataStructure.absolutePathConstraintKind), DCommon.justReturn([constraintLabel("absolute path")])).when(DDataStructure.constraintIdentifier(DDataStructure.segmentPathConstraintKind), DCommon.justReturn([constraintLabel("path segment")])).when(DDataStructure.constraintIdentifier(fileExistConstraintKind), DCommon.justReturn([constraintLabel("exists")])).when(DDataStructure.constraintIdentifier(folderExistConstraintKind), DCommon.justReturn([constraintLabel("exists")])).when(DDataStructure.constraintIdentifier(DDataStructure.strictPositiveConstraintKind), DCommon.justReturn([constraintLabel("> "), literal("0")])).when(DDataStructure.constraintIdentifier(DDataStructure.strictNegativeConstraintKind), DCommon.justReturn([constraintLabel("< "), literal("0")])).when(DDataStructure.constraintIdentifier(DDataStructure.betweenThanConstraintKind), ({ definition }) => [
+		constraintLabel("> "),
+		literal(String(definition.greater)),
+		secondary(" and "),
+		constraintLabel("< "),
+		literal(String(definition.less))
+	]).when(DDataStructure.constraintIdentifier(DDataStructure.betweenThanOrEqualConstraintKind), ({ definition }) => [constraintLabel("range "), literal(`${definition.greater}..${definition.less}`)]).when(DDataStructure.constraintIdentifier(DDataStructure.multipleOfConstraintKind), ({ definition }) => [constraintLabel("multiple of "), literal(String(definition.multiple))]).when(DDataStructure.constraintIdentifier(DDataStructure.regexConstraintKind), ({ definition }) => [constraintLabel("pattern "), literal(definition.regex.toString())]).when(DDataStructure.constraintIdentifier(mimeTypeConstraintKind), ({ definition }) => [constraintLabel("mime "), literal(definition.regex.toString())]).when(DDataStructure.constraintIdentifier(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(DCommon.justReturn(null));
+}
+function renderConstraints(constraints) {
+	return DArray.filter([
+		renderStringLength(constraints),
+		renderArrayLength(constraints),
+		...renderNumberBounds(constraints),
+		...DArray.map(constraints, renderSimpleConstraint)
+	], DCommon.truthy);
+}
+function renderDataStructure(dataStructure) {
+	const constraints = renderConstraints(dataStructure.definition.constraints);
+	if (DDataStructure.structureIdentifier(dataStructure, DDataStructure.lazyStructureKind)) {
+		const inner = renderDataStructure(dataStructure.definition.getter.value);
+		return {
+			main: inner.main,
+			constraints: [...inner.constraints, ...constraints]
+		};
+	}
+	if (DDataStructure.structureIdentifier(dataStructure, DDataStructure.typeStructureKind)) return {
+		main: renderType(dataStructure.definition.type),
+		constraints
+	};
+	if (DDataStructure.structureIdentifier(dataStructure, DDataStructure.arrayStructureKind)) {
+		const element = renderDataStructure(dataStructure.definition.element);
+		return {
+			main: [...element.main, typeLabel("[]")],
+			constraints: [...DArray.map(element.constraints, (constraint) => [constraintLabel("item "), constraint]), ...constraints]
+		};
+	}
+	if (DDataStructure.structureIdentifier(dataStructure, DDataStructure.unionStructureKind)) {
+		const values = DCommon.pipe(dataStructure.definition.values.value, DArray.filter((structure) => !DDataStructure.isUndefinedStructure(structure)), DArray.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: DArray.reduce(DArray.map(values, ({ main }) => main), DArray.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 DArray.map(constraints, (constraint) => renderInline([secondary("↳ "), constraint], depth));
+}
+function renderDescriptionLine(description, depth) {
+	return description ? renderInline([secondary(description)], depth) : null;
+}
+function renderUsage(command) {
+	const args = command.subject?.type === "argument" ? DArray.map(command.subject.args, (argument) => argument.optional ? `[${argument.name}]` : `<${argument.name}>`) : command.subject?.type === "subCommand" ? ["<command>"] : [];
+	return DCommon.pipe([
+		command.name,
+		...args,
+		command.options.length > 0 ? "[options]" : null
+	], DArray.filter(DCommon.truthy), DString.join(" "));
+}
+function renderOptionSignature(option) {
+	return [
+		DArray.map(option.aliases, (alias) => [
+			syntax("-"),
+			name(alias),
+			syntax(", ")
+		]),
+		syntax("--"),
+		name(option.name),
+		simpleOptionKind.has(option) ? syntax(" <value>") : null,
+		arrayOptionKind.has(option) ? syntax(" <value...>") : null
+	];
+}
+function renderOptionDetails(option, depth) {
+	if (simpleOptionKind.has(option) || arrayOptionKind.has(option)) {
+		const help = renderDataStructure(option.dataStructure);
+		return DArray.filter([
+			renderInline([renderMetadata(help, option.required ? "required" : "optional")], depth),
+			...renderConstraintLines(help.constraints, depth),
+			renderDescriptionLine(option.description, depth)
+		], DCommon.truthy);
+	}
+	if (booleanOptionKind.has(option)) return DArray.filter([renderInline([typeLabel("boolean")], depth), renderDescriptionLine(option.description, depth)], DCommon.truthy);
+	return DArray.filter([renderDescriptionLine(option.description, depth)], DCommon.truthy);
+}
+function renderOptionsHelp(options, depth) {
+	return DPrinter.renderParagraph([renderInline([section("OPTIONS", "magenta")], depth), DArray.map(options, (option) => DPrinter.renderParagraph([renderInline([renderOptionSignature(option)], depth + 1), renderOptionDetails(option, depth + 2)]))]);
+}
+function renderArgumentsHelp(args, depth) {
+	return DPrinter.renderParagraph([renderInline([section("ARGUMENTS", "cyan")], depth), DArray.map(args, (argument) => {
+		const help = renderDataStructure(argument.dataStructure);
+		return DPrinter.renderParagraph([
+			renderInline([name(argument.name.padEnd(12)), renderMetadata(help, argument.optional ? "optional" : "required")], depth + 1),
+			renderConstraintLines(help.constraints, depth + 2),
+			renderDescriptionLine(argument.description, depth + 2)
+		]);
+	})]);
+}
+function renderSubCommandsHelp(commands, depth) {
+	return DPrinter.renderParagraph([renderInline([section("COMMANDS", "green")], depth), DArray.map(commands, (command) => renderInline([name(command.name.padEnd(16)), command.description ? secondary(command.description) : null], depth + 1))]);
+}
+function renderCommandHelp(command, depth) {
+	return [...DArray.filter([
+		renderInline([
+			section("COMMAND", "green"),
+			"  ",
+			DPrinter.colorizedBold(command.name, "cyan")
+		], depth),
+		renderDescriptionLine(command.description, depth + 1),
+		DPrinter.renderParagraph([renderInline([section("USAGE", "blue")], depth), renderInline([syntax(renderUsage(command))], depth + 1)]),
+		command.subject?.type === "argument" ? renderArgumentsHelp(command.subject.args, depth) : null,
+		command.subject?.type === "subCommand" ? renderSubCommandsHelp(command.subject.subCommands, depth) : null,
+		DArray.minElements(command.options, 1) ? renderOptionsHelp(command.options, depth) : null
+	], DCommon.truthy)];
+}
+function logCommandHelp(command) {
+	console.log(DPrinter.renderParagraph(renderCommandHelp(command, 0)));
+}
+function renderExecOptionHelp(options, depth) {
+	return [renderInline([section("EXEC OPTIONS", "green")], depth), renderOptionsHelp(options, depth)];
+}
+function logExecOptionHelp(options) {
+	console.log(DPrinter.renderParagraph(renderExecOptionHelp(options, 0)));
+}
+//#endregion
+export { helpOption, logCommandHelp, logExecOptionHelp, renderArgumentsHelp, renderCommandHelp, renderExecOptionHelp, renderOptionsHelp };

package/dist/command/index.cjs

@@ -0,0 +1,82 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_argument = require("./argument.cjs");
+const require_error = require("./error.cjs");
+const require_base = require("./options/base.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");
+const require_identifier = require("./options/identifier.cjs");
+const require_help = require("./help.cjs");
+const require_create = require("./create.cjs");
+const require_exec = require("./exec.cjs");
+const require_execOptions = require("./execOptions.cjs");
+//#region scripts/command/index.ts
+var command_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	SymbolCommandError: () => require_error.SymbolCommandError,
+	argumentKind: () => require_argument.argumentKind,
+	arrayOptionKind: () => require_array.arrayOptionKind,
+	booleanOptionKind: () => require_boolean.booleanOptionKind,
+	constructOption: () => require_base.constructOption,
+	create: () => require_create.create,
+	createArgument: () => require_argument.createArgument,
+	createArrayOption: () => require_array.createArrayOption,
+	createBooleanOption: () => require_boolean.createBooleanOption,
+	createError: () => require_error.createError,
+	createOption: () => require_simple.createOption,
+	exec: () => require_exec.exec,
+	execOptions: () => require_execOptions.execOptions,
+	findOptionToken: () => require_base.findOptionToken,
+	helpOption: () => require_help.helpOption,
+	interpretDataStructureError: () => require_error.interpretDataStructureError,
+	interpretErrorIssues: () => require_error.interpretErrorIssues,
+	interpretExecCommandError: () => require_error.interpretExecCommandError,
+	interpretExecOptionsError: () => require_error.interpretExecOptionsError,
+	isCommands: () => require_create.isCommands,
+	isOptionToken: () => require_base.isOptionToken,
+	logCommandHelp: () => require_help.logCommandHelp,
+	logExecOptionHelp: () => require_help.logExecOptionHelp,
+	optionIdentifier: () => require_identifier.optionIdentifier,
+	optionKind: () => require_base.optionKind,
+	renderArgumentsHelp: () => require_help.renderArgumentsHelp,
+	renderCommandHelp: () => require_help.renderCommandHelp,
+	renderExecOptionHelp: () => require_help.renderExecOptionHelp,
+	renderOptionsHelp: () => require_help.renderOptionsHelp,
+	simpleOptionKind: () => require_simple.simpleOptionKind
+});
+//#endregion
+exports.SymbolCommandError = require_error.SymbolCommandError;
+exports.argumentKind = require_argument.argumentKind;
+exports.arrayOptionKind = require_array.arrayOptionKind;
+exports.booleanOptionKind = require_boolean.booleanOptionKind;
+Object.defineProperty(exports, "command_exports", {
+	enumerable: true,
+	get: function() {
+		return command_exports;
+	}
+});
+exports.constructOption = require_base.constructOption;
+exports.create = require_create.create;
+exports.createArgument = require_argument.createArgument;
+exports.createArrayOption = require_array.createArrayOption;
+exports.createBooleanOption = require_boolean.createBooleanOption;
+exports.createError = require_error.createError;
+exports.createOption = require_simple.createOption;
+exports.exec = require_exec.exec;
+exports.execOptions = require_execOptions.execOptions;
+exports.findOptionToken = require_base.findOptionToken;
+exports.helpOption = require_help.helpOption;
+exports.interpretDataStructureError = require_error.interpretDataStructureError;
+exports.interpretErrorIssues = require_error.interpretErrorIssues;
+exports.interpretExecCommandError = require_error.interpretExecCommandError;
+exports.interpretExecOptionsError = require_error.interpretExecOptionsError;
+exports.isCommands = require_create.isCommands;
+exports.isOptionToken = require_base.isOptionToken;
+exports.logCommandHelp = require_help.logCommandHelp;
+exports.logExecOptionHelp = require_help.logExecOptionHelp;
+exports.optionIdentifier = require_identifier.optionIdentifier;
+exports.optionKind = require_base.optionKind;
+exports.renderArgumentsHelp = require_help.renderArgumentsHelp;
+exports.renderCommandHelp = require_help.renderCommandHelp;
+exports.renderExecOptionHelp = require_help.renderExecOptionHelp;
+exports.renderOptionsHelp = require_help.renderOptionsHelp;
+exports.simpleOptionKind = require_simple.simpleOptionKind;

package/dist/command/index.d.ts

@@ -0,0 +1,8 @@
+export type * from './types';
+export * from './argument';
+export * from './options';
+export * from './create';
+export * from './exec';
+export * from './execOptions';
+export * from './error';
+export * from './help';

package/dist/command/index.mjs

@@ -0,0 +1,47 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { argumentKind, createArgument } from "./argument.mjs";
+import { SymbolCommandError, createError, interpretDataStructureError, interpretErrorIssues, interpretExecCommandError, interpretExecOptionsError } from "./error.mjs";
+import { constructOption, findOptionToken, isOptionToken, optionKind } from "./options/base.mjs";
+import { arrayOptionKind, createArrayOption } from "./options/defaults/array.mjs";
+import { booleanOptionKind, createBooleanOption } from "./options/defaults/boolean.mjs";
+import { createOption, simpleOptionKind } from "./options/defaults/simple.mjs";
+import { optionIdentifier } from "./options/identifier.mjs";
+import { helpOption, logCommandHelp, logExecOptionHelp, renderArgumentsHelp, renderCommandHelp, renderExecOptionHelp, renderOptionsHelp } from "./help.mjs";
+import { create, isCommands } from "./create.mjs";
+import { exec } from "./exec.mjs";
+import { execOptions } from "./execOptions.mjs";
+//#region scripts/command/index.ts
+var command_exports = /* @__PURE__ */ __exportAll({
+	SymbolCommandError: () => SymbolCommandError,
+	argumentKind: () => argumentKind,
+	arrayOptionKind: () => arrayOptionKind,
+	booleanOptionKind: () => booleanOptionKind,
+	constructOption: () => constructOption,
+	create: () => create,
+	createArgument: () => createArgument,
+	createArrayOption: () => createArrayOption,
+	createBooleanOption: () => createBooleanOption,
+	createError: () => createError,
+	createOption: () => createOption,
+	exec: () => exec,
+	execOptions: () => execOptions,
+	findOptionToken: () => findOptionToken,
+	helpOption: () => helpOption,
+	interpretDataStructureError: () => interpretDataStructureError,
+	interpretErrorIssues: () => interpretErrorIssues,
+	interpretExecCommandError: () => interpretExecCommandError,
+	interpretExecOptionsError: () => interpretExecOptionsError,
+	isCommands: () => isCommands,
+	isOptionToken: () => isOptionToken,
+	logCommandHelp: () => logCommandHelp,
+	logExecOptionHelp: () => logExecOptionHelp,
+	optionIdentifier: () => optionIdentifier,
+	optionKind: () => optionKind,
+	renderArgumentsHelp: () => renderArgumentsHelp,
+	renderCommandHelp: () => renderCommandHelp,
+	renderExecOptionHelp: () => renderExecOptionHelp,
+	renderOptionsHelp: () => renderOptionsHelp,
+	simpleOptionKind: () => simpleOptionKind
+});
+//#endregion
+export { SymbolCommandError, argumentKind, arrayOptionKind, booleanOptionKind, command_exports, constructOption, create, createArgument, createArrayOption, createBooleanOption, createError, createOption, exec, execOptions, findOptionToken, helpOption, interpretDataStructureError, interpretErrorIssues, interpretExecCommandError, interpretExecOptionsError, isCommands, isOptionToken, logCommandHelp, logExecOptionHelp, optionIdentifier, optionKind, renderArgumentsHelp, renderCommandHelp, renderExecOptionHelp, renderOptionsHelp, simpleOptionKind };

package/dist/command/kind.cjs

@@ -0,0 +1,7 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+let _duplojs_lang_kind = require("@duplojs/lang/kind");
+_duplojs_lang_kind = require_runtime.__toESM(_duplojs_lang_kind, 1);
+//#region scripts/command/kind.ts
+const createKind = _duplojs_lang_kind.createNamespace("DuplojsServerCommand");
+//#endregion
+exports.createKind = createKind;

package/dist/command/kind.d.ts

@@ -0,0 +1,2 @@
+import * as DKind from "@duplojs/lang/kind";
+export declare const createKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import('@duplojs/lang/string').ForbiddenContain<GenericName, DKind.ForbiddenKindNameCharacter>) => DKind.Handler<DKind.Definition<`@DuplojsServerCommand/${GenericName}`, GenericKindValue>>;

package/dist/command/kind.mjs

@@ -0,0 +1,5 @@
+import * as DKind from "@duplojs/lang/kind";
+//#region scripts/command/kind.ts
+const createKind = DKind.createNamespace("DuplojsServerCommand");
+//#endregion
+export { createKind };

package/dist/command/options/base.cjs

@@ -0,0 +1,76 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("../kind.cjs");
+const require_error = require("../error.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 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);
+//#region scripts/command/options/base.ts
+const optionKind = require_kind.createKind("command-option");
+const regexOption = /^(?<dashes>-{1,2})(?<key>(?![0-9]+(?:=|$))[A-Za-z0-9][A-Za-z0-9_-]*)(?:=(?<value>.*))?$/;
+function isOptionToken(input) {
+	return _duplojs_lang_string.test(input, regexOption);
+}
+function findOptionToken(args, option) {
+	return _duplojs_lang_array.reduce(args, _duplojs_lang_array.reduceFrom(null), ({ element, next, exit, index }) => {
+		const extractResult = _duplojs_lang_string.extract(element, regexOption);
+		if (!extractResult) return next(null);
+		const key = extractResult.namedGroups.key;
+		if (option.name !== key && (!_duplojs_lang_array.includes(option.aliases, key) || extractResult.namedGroups?.dashes !== "-")) return next(null);
+		return exit({
+			key,
+			value: extractResult.namedGroups?.value,
+			index
+		});
+	});
+}
+function constructOption(kindHandler, createConstructor) {
+	return createConstructor({ init: (name, execute, params, ...rest) => {
+		const self = {
+			...Object.fromEntries(Object.entries(rest[0] ?? {}).map(([key, prop]) => typeof prop === "function" ? [key, (...args) => prop(self, ...args)] : [key, prop])),
+			name,
+			execute: async (args, error) => {
+				const result = findOptionToken(args, self);
+				const { value, argumentRest } = _duplojs_lang_common.justExec(() => {
+					if (!result) return {
+						value: null,
+						argumentRest: args
+					};
+					if (result.value === void 0) {
+						const nextArg = args[result.index + 1];
+						if (nextArg === void 0 || isOptionToken(nextArg)) return {
+							value: void 0,
+							argumentRest: _duplojs_lang_array.spliceDelete(args, result.index, 1)
+						};
+						return {
+							value: nextArg,
+							argumentRest: _duplojs_lang_array.spliceDelete(args, result.index, 2)
+						};
+					}
+					return {
+						value: result.value,
+						argumentRest: _duplojs_lang_array.spliceDelete(args, result.index, 1)
+					};
+				});
+				const executeResult = await execute(self, value, error);
+				if (executeResult === require_error.SymbolCommandError) return require_error.SymbolCommandError;
+				return {
+					result: executeResult,
+					argumentRest
+				};
+			},
+			aliases: params?.aliases ?? [],
+			description: params?.description ?? null,
+			[optionKind.runTimeKey]: null,
+			[kindHandler.runTimeKey]: null
+		};
+		return self;
+	} });
+}
+//#endregion
+exports.constructOption = constructOption;
+exports.findOptionToken = findOptionToken;
+exports.isOptionToken = isOptionToken;
+exports.optionKind = optionKind;

package/dist/command/options/base.d.ts

@@ -0,0 +1,30 @@
+import { Error, SymbolCommandError } from '../error';
+import * as DCommon from "@duplojs/lang/common";
+import type * as DKind from "@duplojs/lang/kind";
+export declare const optionKind: DKind.Handler<DKind.Definition<"@DuplojsServerCommand/command-option", unknown>>;
+export declare function isOptionToken(input: string): boolean;
+export declare function findOptionToken(args: readonly string[], option: Pick<Option, "name" | "aliases">): {
+    key: string;
+    value: string | undefined;
+    index: number;
+} | null;
+export interface Option<GenericName extends string = string, GenericValue extends unknown = unknown> extends DKind.Kind<typeof optionKind> {
+    readonly name: GenericName;
+    readonly description: string | null;
+    readonly aliases: readonly string[];
+    execute(args: readonly string[], error: Error): Promise<{
+        result: GenericValue;
+        argumentRest: readonly string[];
+    } | SymbolCommandError>;
+}
+export interface CreateOptionInitParams {
+    description: string | null;
+    aliases: readonly string[];
+}
+export type CreateOptionInitRest<GenericOption extends Option = Option> = {
+    [Prop in Exclude<keyof GenericOption, keyof Option>]: GenericOption[Prop] extends DCommon.AnyFunction ? (self: GenericOption, ...args: Parameters<GenericOption[Prop]>) => ReturnType<GenericOption[Prop]> : GenericOption[Prop];
+};
+export interface CreateOptionConstructorParams<GenericKindHandler extends DKind.Handler = DKind.Handler> {
+    init<GenericOption extends (Option & DKind.Kind<GenericKindHandler>)>(name: GenericOption["name"], execute: (self: GenericOption, value: string | undefined | null, error: Error) => DCommon.MaybePromise<Extract<Awaited<ReturnType<GenericOption["execute"]>>, object>["result"] | SymbolCommandError>, params: CreateOptionInitParams, ...args: DCommon.IsNever<Exclude<keyof GenericOption, keyof Option>> extends true ? [] : [rest: CreateOptionInitRest<GenericOption>]): NoInfer<GenericOption>;
+}
+export declare function constructOption<GenericKindHandler extends DKind.Handler, GenericConstructor extends ((...args: any[]) => (Option & DKind.Kind<GenericKindHandler>))>(kindHandler: GenericKindHandler, createConstructor: (params: CreateOptionConstructorParams<GenericKindHandler>) => GenericConstructor): GenericConstructor;

package/dist/command/options/base.mjs

@@ -0,0 +1,69 @@
+import { createKind } from "../kind.mjs";
+import { SymbolCommandError } from "../error.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DArray from "@duplojs/lang/array";
+import * as DString from "@duplojs/lang/string";
+//#region scripts/command/options/base.ts
+const optionKind = createKind("command-option");
+const regexOption = /^(?<dashes>-{1,2})(?<key>(?![0-9]+(?:=|$))[A-Za-z0-9][A-Za-z0-9_-]*)(?:=(?<value>.*))?$/;
+function isOptionToken(input) {
+	return DString.test(input, regexOption);
+}
+function findOptionToken(args, option) {
+	return DArray.reduce(args, DArray.reduceFrom(null), ({ element, next, exit, index }) => {
+		const extractResult = DString.extract(element, regexOption);
+		if (!extractResult) return next(null);
+		const key = extractResult.namedGroups.key;
+		if (option.name !== key && (!DArray.includes(option.aliases, key) || extractResult.namedGroups?.dashes !== "-")) return next(null);
+		return exit({
+			key,
+			value: extractResult.namedGroups?.value,
+			index
+		});
+	});
+}
+function constructOption(kindHandler, createConstructor) {
+	return createConstructor({ init: (name, execute, params, ...rest) => {
+		const self = {
+			...Object.fromEntries(Object.entries(rest[0] ?? {}).map(([key, prop]) => typeof prop === "function" ? [key, (...args) => prop(self, ...args)] : [key, prop])),
+			name,
+			execute: async (args, error) => {
+				const result = findOptionToken(args, self);
+				const { value, argumentRest } = DCommon.justExec(() => {
+					if (!result) return {
+						value: null,
+						argumentRest: args
+					};
+					if (result.value === void 0) {
+						const nextArg = args[result.index + 1];
+						if (nextArg === void 0 || isOptionToken(nextArg)) return {
+							value: void 0,
+							argumentRest: DArray.spliceDelete(args, result.index, 1)
+						};
+						return {
+							value: nextArg,
+							argumentRest: DArray.spliceDelete(args, result.index, 2)
+						};
+					}
+					return {
+						value: result.value,
+						argumentRest: DArray.spliceDelete(args, result.index, 1)
+					};
+				});
+				const executeResult = await execute(self, value, error);
+				if (executeResult === SymbolCommandError) return SymbolCommandError;
+				return {
+					result: executeResult,
+					argumentRest
+				};
+			},
+			aliases: params?.aliases ?? [],
+			description: params?.description ?? null,
+			[optionKind.runTimeKey]: null,
+			[kindHandler.runTimeKey]: null
+		};
+		return self;
+	} });
+}
+//#endregion
+export { constructOption, findOptionToken, isOptionToken, optionKind };

package/dist/command/options/defaults/array.cjs

@@ -0,0 +1,35 @@
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
+const require_string = require("../../../dataStructure/common/codec/defaults/string.cjs");
+const require_kind = require("../../kind.cjs");
+const require_base = require("../base.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+let _duplojs_lang_string = require("@duplojs/lang/string");
+_duplojs_lang_string = require_runtime.__toESM(_duplojs_lang_string, 1);
+//#region scripts/command/options/defaults/array.ts
+const defaultSeparator = ",";
+const arrayOptionKind = require_kind.createKind("command-array-option");
+const createArrayOption = require_base.constructOption(arrayOptionKind, ({ init }) => (name, dataStructure, params) => init(name, async (self, value, error) => {
+	if (value === null && self.required === true) return error.addRequiredOptionIssue(self.name);
+	if (value === null) return;
+	if (value === void 0) return error.addRequiredOptionValueIssue(self.name);
+	const result = await self.dataStructure.asyncDecode(require_string.codecsString, _duplojs_lang_string.split(value, self.separator));
+	if (_duplojs_lang_either.isLeft(result)) return error.addDataStructureOptionIssue(self.name, value, _duplojs_lang_either.unwrapLeft(result));
+	return _duplojs_lang_either.unwrapRight(result);
+}, {
+	description: params?.description ?? null,
+	aliases: params?.aliases ?? []
+}, {
+	dataStructure: _duplojs_lang_common.justExec(() => _duplojs_lang_common.pipe(dataStructure, _duplojs_lang_dataStructure.array, (dataStructure) => params?.min !== void 0 ? dataStructure.addConstraint(_duplojs_lang_dataStructure.minElements(params.min)) : dataStructure, (dataStructure) => params?.max !== void 0 ? dataStructure.addConstraint(_duplojs_lang_dataStructure.maxElements(params.max)) : dataStructure)),
+	required: params?.required ?? false,
+	min: params?.min,
+	max: params?.max,
+	separator: params?.separator ?? defaultSeparator
+}));
+//#endregion
+exports.arrayOptionKind = arrayOptionKind;
+exports.createArrayOption = createArrayOption;

package/dist/command/options/defaults/array.d.ts

@@ -0,0 +1,26 @@
+import { Option } from '../base';
+import { EligibleType, ForbiddenInvalidIdentifier } from '../../types';
+import * as DCommon from "@duplojs/lang/common";
+import type * as DKind from "@duplojs/lang/kind";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DNumber from "@duplojs/lang/number";
+import type * as DArray from "@duplojs/lang/array";
+export declare const arrayOptionKind: DKind.Handler<DKind.Definition<"@DuplojsServerCommand/command-array-option", unknown>>;
+export interface ArrayOption<GenericName extends string = string, GenericValue extends (readonly EligibleType[] | undefined) = (readonly EligibleType[] | undefined)> extends DCommon.Forward<Option<GenericName, GenericValue> & DKind.Kind<typeof arrayOptionKind>> {
+    readonly dataStructure: DDataStructure.Structure<GenericValue>;
+    readonly required: boolean;
+    readonly separator: string;
+    readonly min?: number;
+    readonly max?: number;
+}
+export interface CreateArrayOptionParams<GenericAliases extends readonly string[] = readonly string[]> {
+    description?: string;
+    aliases?: (GenericAliases & {
+        readonly [Index in keyof GenericAliases]: ForbiddenInvalidIdentifier<GenericAliases[Index]>;
+    });
+    min?: number;
+    max?: number;
+    required?: boolean;
+    separator?: string;
+}
+export declare const createArrayOption: <GenericName extends string, GenericStructure extends DDataStructure.Structure<EligibleType>, GenericValue extends DDataStructure.StructureValue<GenericStructure>, const GenericAliases extends readonly string[] = readonly string[], const GenericParams extends CreateArrayOptionParams<GenericAliases> = {}>(name: GenericName & ForbiddenInvalidIdentifier<GenericName>, dataStructure: GenericStructure, params?: GenericParams & CreateArrayOptionParams<GenericAliases>) => ArrayOption<GenericName, ((readonly GenericValue[] & (DNumber.IsLiteral<Extract<GenericParams["min"], number>> extends true ? DArray.MinElements<Extract<GenericParams["min"], number>> : unknown) & (DNumber.IsLiteral<Extract<GenericParams["max"], number>> extends true ? DArray.MaxElements<Extract<GenericParams["max"], number>> : unknown)) | (DCommon.IsEqual<GenericParams["required"], true> extends true ? never : undefined))>;