zod-args-parser 2.0.0-beta.0 → 2.0.0-beta.2

package/lib/esm/definitions/define-cli.js

@@ -1,2 +1,89 @@
-import{generateCliHelpMessage}from"../help-message/generate-for-cli.js";import{generateSubcommandHelpMessage}from"../help-message/generate-for-subcommand.js";import{buildObjectContext}from"../parse/context/object-context-builder.js";import{safeParse,safeParseAsync}from"../parse/safe-parse.js";import{validate}from"../parse/validation/validate-context.js";import{prepareDefinitionTypes}from"../utilities.js";function defineCLI(e){const n=e;if(prepareDefinitionTypes(n.options),prepareDefinitionTypes(n.arguments),n.subcommands)for(const e of Object.values(n.subcommands))prepareDefinitionTypes(e.options),prepareDefinitionTypes(e.arguments);const s={generateCliHelpMessage:e=>generateCliHelpMessage(n,e),generateSubcommandHelpMessage(e,s){const o=n.subcommands?.find(n=>n.name===e);if(!o)throw new Error(`Subcommand ${e} not found`);return generateSubcommandHelpMessage(o,s,n.cliName)}};if(Object.assign(n,s),n.subcommands)for(const e of n.subcommands)Object.assign(e,s);return Object.assign(n,{execute:e=>{if(e??(e={}),!n._onExecute)throw new Error("Action is not defined");const s=buildObjectContext(e,n),o=validate(s,n);if(n._onExecute)for(const e of n._onExecute)e(o)},onExecute:e=>(n._onExecute??(n._onExecute=[]),n._onExecute.push(e),()=>{const s=n._onExecute?.indexOf(e);!s||s<0||n._onExecute?.splice(s,1)}),run:e=>safeParse(e,n),runAsync:e=>safeParseAsync(e,n)})}export{defineCLI};
-//# sourceMappingURL=define-cli.js.map
+// src/definitions/define-cli.ts
+import { CliError } from "../cli-error/cli-error.js";
+import { ErrorCause } from "../cli-error/error-cause.js";
+import { DefinitionErrorCode } from "../cli-error/error-code/definition-error-code.js";
+import { generateCliHelpMessage } from "../help-message/generate-for-cli.js";
+import { generateSubcommandHelpMessage } from "../help-message/generate-for-subcommand.js";
+import { buildObjectContext } from "../parse/context/object-context-builder.js";
+import { safeParse, safeParseAsync } from "../parse/safe-parse.js";
+import { validate } from "../parse/validation/validate-context.js";
+import { prepareDefinitionTypes } from "../utilities/schema-utilities.js";
+function defineCLI(input) {
+  const cliDefinition = input;
+  prepareDefinitionTypes(cliDefinition.options);
+  prepareDefinitionTypes(cliDefinition.arguments);
+  if (cliDefinition.subcommands) {
+    for (const subcommand of Object.values(cliDefinition.subcommands)) {
+      prepareDefinitionTypes(subcommand.options);
+      prepareDefinitionTypes(subcommand.arguments);
+    }
+  }
+  const onExecute = (handler) => {
+    cliDefinition._onExecute ??= [];
+    cliDefinition._onExecute.push(handler);
+    return () => {
+      const handlerIndex = cliDefinition._onExecute?.indexOf(handler);
+      if (!handlerIndex || handlerIndex < 0) return;
+      cliDefinition._onExecute?.splice(handlerIndex, 1);
+    };
+  };
+  const execute = (inputValues) => {
+    inputValues ??= {};
+    const handlers = cliDefinition._onExecute;
+    if (!handlers) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.MissingOnExecute,
+        context: { commandKind: "command", commandName: cliDefinition.cliName }
+      });
+    }
+    const context = buildObjectContext(inputValues, cliDefinition);
+    const validateResult = validate(context, cliDefinition);
+    for (const handler of handlers) {
+      void handler(validateResult);
+    }
+  };
+  const executeAsync = async (inputValues) => {
+    inputValues ??= {};
+    const handlers = cliDefinition._onExecute;
+    if (!handlers) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.MissingOnExecute,
+        context: { commandKind: "command", commandName: cliDefinition.cliName }
+      });
+    }
+    const context = buildObjectContext(inputValues, cliDefinition);
+    const validateResult = validate(context, cliDefinition);
+    await Promise.all(handlers.map(async (handler) => await handler(validateResult)));
+  };
+  const generateHelpMethods = {
+    generateCliHelpMessage(options) {
+      return generateCliHelpMessage(cliDefinition, options);
+    },
+    generateSubcommandHelpMessage(subcommandName, options) {
+      const foundSubcommand = cliDefinition.subcommands?.find((s) => s.name === subcommandName);
+      if (!foundSubcommand) {
+        throw new CliError({
+          cause: ErrorCause.Definition,
+          code: DefinitionErrorCode.SubcommandHelpNotFound,
+          context: { cliName: cliDefinition.cliName, subcommandName }
+        });
+      }
+      return generateSubcommandHelpMessage(foundSubcommand, options, cliDefinition.cliName);
+    }
+  };
+  Object.assign(cliDefinition, generateHelpMethods);
+  if (cliDefinition.subcommands) {
+    for (const subcommandSchema of cliDefinition.subcommands) {
+      Object.assign(subcommandSchema, generateHelpMethods);
+    }
+  }
+  const run = (stringOrArgv) => safeParse(stringOrArgv, cliDefinition);
+  const runAsync = (stringOrArgv) => safeParseAsync(stringOrArgv, cliDefinition);
+  return Object.assign(cliDefinition, { onExecute, execute, executeAsync, run, runAsync });
+}
+export {
+  defineCLI
+};
+//# sourceMappingURL=define-cli.js.map

package/lib/esm/definitions/define-cli.js.map

@@ -1 +1,7 @@
-{"version":3,"names":["generateCliHelpMessage","generateSubcommandHelpMessage","buildObjectContext","safeParse","safeParseAsync","validate","prepareDefinitionTypes","defineCLI","input","cliSchema","options","arguments","subcommands","subcommand","Object","values","generateHelpMethods","subcommandName","foundSubcommand","find","s","name","Error","cliName","assign","subcommandSchema","execute","inputValues","_onExecute","context","validateResult","handler","onExecute","push","handlerIndex","indexOf","splice","run","stringOrArgv","runAsync"],"sources":["../../../src/definitions/define-cli.ts"],"sourcesContent":["import { generateCliHelpMessage } from \"../help-message/generate-for-cli.ts\";\nimport { generateSubcommandHelpMessage } from \"../help-message/generate-for-subcommand.ts\";\nimport { buildObjectContext } from \"../parse/context/object-context-builder.ts\";\nimport { safeParse, safeParseAsync } from \"../parse/safe-parse.ts\";\nimport { validate } from \"../parse/validation/validate-context.ts\";\nimport { prepareDefinitionTypes } from \"../utilities.ts\";\n\nimport type { Argument, Cli, Option, Subcommand } from \"../types/definitions-types.ts\";\nimport type { PrintHelpOptions } from \"../types/help-message-types.ts\";\nimport type { AttachedMethods, AttachedMethodsWide, ValidateMethods } from \"../types/types.ts\";\nimport type { Prettify } from \"../types/utilities-types.ts\";\n\ntype OptionsInput<T> =\n  T extends Record<string, Option> ? { [OptionName in keyof T]: Option<T[OptionName][\"schema\"]> } : T;\n\ntype ArgumentsInput<T> =\n  T extends Record<string, Argument> ? { [ArgumentName in keyof T]: Argument<T[ArgumentName][\"schema\"]> } : T;\n\ntype SubcommandsInput<T extends readonly [Subcommand, ...Subcommand[]]> = {\n  [SubcommandIndex in keyof T]: {\n    [K in keyof T[SubcommandIndex]]: T[SubcommandIndex][K] extends Record<string, Option>\n      ? OptionsInput<T[SubcommandIndex][K]>\n      : T[SubcommandIndex][K] extends Record<string, Argument>\n        ? ArgumentsInput<T[SubcommandIndex][K]>\n        : T[SubcommandIndex][K];\n  } & Subcommand;\n};\n\n// This will prevent extra keys and enable jsdoc on hover\ntype CliInput<T extends Cli> = {\n  [K in keyof T]: K extends keyof Cli\n    ? T[K] extends readonly [Subcommand, ...Subcommand[]]\n      ? SubcommandsInput<T[K]>\n      : K extends \"options\"\n        ? OptionsInput<T[K]>\n        : K extends \"arguments\"\n          ? ArgumentsInput<T[K]>\n          : T[K]\n    : never;\n};\n\nexport function defineCLI<T extends Cli>(input: CliInput<T> & Cli) {\n  const cliSchema = input as Prettify<T & AttachedMethods<T> & ValidateMethods<T>>;\n\n  prepareDefinitionTypes(cliSchema.options);\n  prepareDefinitionTypes(cliSchema.arguments);\n\n  if (cliSchema.subcommands) {\n    for (const subcommand of Object.values(cliSchema.subcommands)) {\n      prepareDefinitionTypes(subcommand.options);\n      prepareDefinitionTypes(subcommand.arguments);\n    }\n  }\n\n  const onExecute = (handler: (Cli[\"_onExecute\"] & {})[number]) => {\n    cliSchema._onExecute ??= [];\n    cliSchema._onExecute.push(handler);\n\n    return () => {\n      const handlerIndex = cliSchema._onExecute?.indexOf(handler);\n      if (!handlerIndex || handlerIndex < 0) return;\n      cliSchema._onExecute?.splice(handlerIndex, 1);\n    };\n  };\n\n  const execute: AttachedMethodsWide[\"execute\"] = inputValues => {\n    inputValues ??= {};\n    if (!cliSchema._onExecute) throw new Error(\"Action is not defined\");\n    const context = buildObjectContext(inputValues, cliSchema);\n    const validateResult = validate(context, cliSchema);\n\n    if (cliSchema._onExecute) {\n      for (const handler of cliSchema._onExecute) {\n        handler(validateResult);\n      }\n    }\n  };\n\n  // Add print methods for CLI schema and its subcommands\n  const generateHelpMethods: Pick<AttachedMethodsWide, \"generateCliHelpMessage\" | \"generateSubcommandHelpMessage\"> = {\n    generateCliHelpMessage(options?: PrintHelpOptions) {\n      return generateCliHelpMessage(cliSchema, options);\n    },\n    generateSubcommandHelpMessage(subcommandName: string, options?: PrintHelpOptions) {\n      const foundSubcommand = cliSchema.subcommands?.find(s => s.name === subcommandName);\n      if (!foundSubcommand) throw new Error(`Subcommand ${subcommandName} not found`);\n      return generateSubcommandHelpMessage(foundSubcommand, options, cliSchema.cliName);\n    },\n  };\n\n  Object.assign(cliSchema, generateHelpMethods);\n\n  if (cliSchema.subcommands) {\n    for (const subcommandSchema of cliSchema.subcommands) {\n      Object.assign(subcommandSchema, generateHelpMethods);\n    }\n  }\n\n  return Object.assign(cliSchema, {\n    execute,\n    onExecute,\n    run: (stringOrArgv: string | string[]) => safeParse(stringOrArgv, cliSchema),\n    runAsync: (stringOrArgv: string | string[]) => safeParseAsync(stringOrArgv, cliSchema),\n  });\n}\n"],"mappings":"OAASA,2BAA8B,6CAC9BC,kCAAqC,oDACrCC,uBAA0B,oDAC1BC,UAAWC,mBAAsB,gCACjCC,aAAgB,iDAChBC,2BAA8B,kBAoChC,SAASC,UAAyBC,GACvC,MAAMC,EAAYD,EAKlB,GAHAF,uBAAuBG,EAAUC,SACjCJ,uBAAuBG,EAAUE,WAE7BF,EAAUG,YACZ,UAAWC,KAAcC,OAAOC,OAAON,EAAUG,aAC/CN,uBAAuBO,EAAWH,SAClCJ,uBAAuBO,EAAWF,WAItC,MAyBMK,EAA6G,CACjHhB,uBAAuBU,GACdV,uBAAuBS,EAAWC,GAE3C,6BAAAT,CAA8BgB,EAAwBP,GACpD,MAAMQ,EAAkBT,EAAUG,aAAaO,KAAKC,GAAKA,EAAEC,OAASJ,GACpE,IAAKC,EAAiB,MAAM,IAAII,MAAM,cAAcL,eACpD,OAAOhB,8BAA8BiB,EAAiBR,EAASD,EAAUc,QAC3E,GAKF,GAFAT,OAAOU,OAAOf,EAAWO,GAErBP,EAAUG,YACZ,UAAWa,KAAoBhB,EAAUG,YACvCE,OAAOU,OAAOC,EAAkBT,GAIpC,OAAOF,OAAOU,OAAOf,EAAW,CAC9BiB,QAlC8CC,IAE9C,GADAA,MAAgB,CAAC,IACZlB,EAAUmB,WAAY,MAAM,IAAIN,MAAM,yBAC3C,MAAMO,EAAU3B,mBAAmByB,EAAalB,GAC1CqB,EAAiBzB,SAASwB,EAASpB,GAEzC,GAAIA,EAAUmB,WACZ,UAAWG,KAAWtB,EAAUmB,WAC9BG,EAAQD,IA2BZE,UA9CiBD,IACjBtB,EAAUmB,aAAVnB,EAAUmB,WAAe,IACzBnB,EAAUmB,WAAWK,KAAKF,GAEnB,KACL,MAAMG,EAAezB,EAAUmB,YAAYO,QAAQJ,IAC9CG,GAAgBA,EAAe,GACpCzB,EAAUmB,YAAYQ,OAAOF,EAAc,KAwC7CG,IAAMC,GAAoCnC,UAAUmC,EAAc7B,GAClE8B,SAAWD,GAAoClC,eAAekC,EAAc7B,IAEhF,Q","ignoreList":[]}
+{
+  "version": 3,
+  "sources": ["../../../src/definitions/define-cli.ts"],
+  "sourcesContent": ["import { CliError } from \"../cli-error/cli-error.ts\";\nimport { ErrorCause } from \"../cli-error/error-cause.ts\";\nimport { DefinitionErrorCode } from \"../cli-error/error-code/definition-error-code.ts\";\nimport { generateCliHelpMessage } from \"../help-message/generate-for-cli.ts\";\nimport { generateSubcommandHelpMessage } from \"../help-message/generate-for-subcommand.ts\";\nimport { buildObjectContext } from \"../parse/context/object-context-builder.ts\";\nimport { safeParse, safeParseAsync } from \"../parse/safe-parse.ts\";\nimport { validate } from \"../parse/validation/validate-context.ts\";\nimport { prepareDefinitionTypes } from \"../utilities/schema-utilities.ts\";\n\nimport type { Argument, Cli, Option, Subcommand } from \"../types/definitions-types.ts\";\nimport type { PrintHelpOptions } from \"../types/help-message-types.ts\";\nimport type { AttachedMethods, AttachedMethodsWide, ValidateMethods } from \"../types/types.ts\";\nimport type { Prettify } from \"../types/utilities-types.ts\";\n\ntype OptionsInput<T> =\n  T extends Record<string, Option> ? { [OptionName in keyof T]: Option<T[OptionName][\"schema\"]> } : T;\n\ntype ArgumentsInput<T> =\n  T extends Record<string, Argument> ? { [ArgumentName in keyof T]: Argument<T[ArgumentName][\"schema\"]> } : T;\n\ntype SubcommandsInput<T extends readonly [Subcommand, ...Subcommand[]]> = {\n  [SubcommandIndex in keyof T]: {\n    [K in keyof T[SubcommandIndex]]: T[SubcommandIndex][K] extends Record<string, Option>\n      ? OptionsInput<T[SubcommandIndex][K]>\n      : T[SubcommandIndex][K] extends Record<string, Argument>\n        ? ArgumentsInput<T[SubcommandIndex][K]>\n        : T[SubcommandIndex][K];\n  } & Subcommand;\n};\n\n// This will prevent extra keys and enable jsdoc on hover\ntype CliInput<T extends Cli> = {\n  [K in keyof T]: K extends keyof Cli\n    ? T[K] extends readonly [Subcommand, ...Subcommand[]]\n      ? SubcommandsInput<T[K]>\n      : K extends \"options\"\n        ? OptionsInput<T[K]>\n        : K extends \"arguments\"\n          ? ArgumentsInput<T[K]>\n          : T[K]\n    : never;\n};\n\nexport function defineCLI<T extends Cli>(input: CliInput<T> & Cli) {\n  const cliDefinition = input as T;\n\n  prepareDefinitionTypes(cliDefinition.options);\n  prepareDefinitionTypes(cliDefinition.arguments);\n\n  if (cliDefinition.subcommands) {\n    for (const subcommand of Object.values(cliDefinition.subcommands)) {\n      prepareDefinitionTypes(subcommand.options);\n      prepareDefinitionTypes(subcommand.arguments);\n    }\n  }\n\n  const onExecute = (handler: (Cli[\"_onExecute\"] & {})[number]) => {\n    cliDefinition._onExecute ??= [];\n    cliDefinition._onExecute.push(handler);\n\n    return () => {\n      const handlerIndex = cliDefinition._onExecute?.indexOf(handler);\n      if (!handlerIndex || handlerIndex < 0) return;\n      cliDefinition._onExecute?.splice(handlerIndex, 1);\n    };\n  };\n\n  const execute: AttachedMethodsWide[\"execute\"] = inputValues => {\n    inputValues ??= {};\n\n    const handlers = cliDefinition._onExecute;\n    if (!handlers) {\n      throw new CliError({\n        cause: ErrorCause.Definition,\n        code: DefinitionErrorCode.MissingOnExecute,\n        context: { commandKind: \"command\", commandName: cliDefinition.cliName },\n      });\n    }\n\n    const context = buildObjectContext(inputValues, cliDefinition);\n    const validateResult = validate(context, cliDefinition);\n\n    for (const handler of handlers) {\n      void handler(validateResult);\n    }\n  };\n\n  const executeAsync: AttachedMethodsWide[\"executeAsync\"] = async inputValues => {\n    inputValues ??= {};\n\n    const handlers = cliDefinition._onExecute;\n\n    if (!handlers) {\n      throw new CliError({\n        cause: ErrorCause.Definition,\n        code: DefinitionErrorCode.MissingOnExecute,\n        context: { commandKind: \"command\", commandName: cliDefinition.cliName },\n      });\n    }\n\n    const context = buildObjectContext(inputValues, cliDefinition);\n    const validateResult = validate(context, cliDefinition);\n\n    await Promise.all(handlers.map(async handler => await handler(validateResult)));\n  };\n\n  // Add print methods for CLI schema and its subcommands\n  const generateHelpMethods: Pick<AttachedMethodsWide, \"generateCliHelpMessage\" | \"generateSubcommandHelpMessage\"> = {\n    generateCliHelpMessage(options?: PrintHelpOptions) {\n      return generateCliHelpMessage(cliDefinition, options);\n    },\n    generateSubcommandHelpMessage(subcommandName: string, options?: PrintHelpOptions) {\n      const foundSubcommand = cliDefinition.subcommands?.find(s => s.name === subcommandName);\n      if (!foundSubcommand) {\n        throw new CliError({\n          cause: ErrorCause.Definition,\n          code: DefinitionErrorCode.SubcommandHelpNotFound,\n          context: { cliName: cliDefinition.cliName, subcommandName },\n        });\n      }\n      return generateSubcommandHelpMessage(foundSubcommand, options, cliDefinition.cliName);\n    },\n  };\n\n  Object.assign(cliDefinition, generateHelpMethods);\n\n  if (cliDefinition.subcommands) {\n    for (const subcommandSchema of cliDefinition.subcommands) {\n      Object.assign(subcommandSchema, generateHelpMethods);\n    }\n  }\n\n  const run = (stringOrArgv: string | string[]) => safeParse(stringOrArgv, cliDefinition);\n  const runAsync = (stringOrArgv: string | string[]) => safeParseAsync(stringOrArgv, cliDefinition);\n\n  return Object.assign(cliDefinition, { onExecute, execute, executeAsync, run, runAsync }) as Prettify<\n    T & AttachedMethods<T> & ValidateMethods<T>\n  >;\n}\n"],
+  "mappings": ";AAAA,SAAS,gBAAgB;AACzB,SAAS,kBAAkB;AAC3B,SAAS,2BAA2B;AACpC,SAAS,8BAA8B;AACvC,SAAS,qCAAqC;AAC9C,SAAS,0BAA0B;AACnC,SAAS,WAAW,sBAAsB;AAC1C,SAAS,gBAAgB;AACzB,SAAS,8BAA8B;AAoChC,SAAS,UAAyB,OAA0B;AACjE,QAAM,gBAAgB;AAEtB,yBAAuB,cAAc,OAAO;AAC5C,yBAAuB,cAAc,SAAS;AAE9C,MAAI,cAAc,aAAa;AAC7B,eAAW,cAAc,OAAO,OAAO,cAAc,WAAW,GAAG;AACjE,6BAAuB,WAAW,OAAO;AACzC,6BAAuB,WAAW,SAAS;AAAA,IAC7C;AAAA,EACF;AAEA,QAAM,YAAY,CAAC,YAA8C;AAC/D,kBAAc,eAAe,CAAC;AAC9B,kBAAc,WAAW,KAAK,OAAO;AAErC,WAAO,MAAM;AACX,YAAM,eAAe,cAAc,YAAY,QAAQ,OAAO;AAC9D,UAAI,CAAC,gBAAgB,eAAe,EAAG;AACvC,oBAAc,YAAY,OAAO,cAAc,CAAC;AAAA,IAClD;AAAA,EACF;AAEA,QAAM,UAA0C,iBAAe;AAC7D,oBAAgB,CAAC;AAEjB,UAAM,WAAW,cAAc;AAC/B,QAAI,CAAC,UAAU;AACb,YAAM,IAAI,SAAS;AAAA,QACjB,OAAO,WAAW;AAAA,QAClB,MAAM,oBAAoB;AAAA,QAC1B,SAAS,EAAE,aAAa,WAAW,aAAa,cAAc,QAAQ;AAAA,MACxE,CAAC;AAAA,IACH;AAEA,UAAM,UAAU,mBAAmB,aAAa,aAAa;AAC7D,UAAM,iBAAiB,SAAS,SAAS,aAAa;AAEtD,eAAW,WAAW,UAAU;AAC9B,WAAK,QAAQ,cAAc;AAAA,IAC7B;AAAA,EACF;AAEA,QAAM,eAAoD,OAAM,gBAAe;AAC7E,oBAAgB,CAAC;AAEjB,UAAM,WAAW,cAAc;AAE/B,QAAI,CAAC,UAAU;AACb,YAAM,IAAI,SAAS;AAAA,QACjB,OAAO,WAAW;AAAA,QAClB,MAAM,oBAAoB;AAAA,QAC1B,SAAS,EAAE,aAAa,WAAW,aAAa,cAAc,QAAQ;AAAA,MACxE,CAAC;AAAA,IACH;AAEA,UAAM,UAAU,mBAAmB,aAAa,aAAa;AAC7D,UAAM,iBAAiB,SAAS,SAAS,aAAa;AAEtD,UAAM,QAAQ,IAAI,SAAS,IAAI,OAAM,YAAW,MAAM,QAAQ,cAAc,CAAC,CAAC;AAAA,EAChF;AAGA,QAAM,sBAA6G;AAAA,IACjH,uBAAuB,SAA4B;AACjD,aAAO,uBAAuB,eAAe,OAAO;AAAA,IACtD;AAAA,IACA,8BAA8B,gBAAwB,SAA4B;AAChF,YAAM,kBAAkB,cAAc,aAAa,KAAK,OAAK,EAAE,SAAS,cAAc;AACtF,UAAI,CAAC,iBAAiB;AACpB,cAAM,IAAI,SAAS;AAAA,UACjB,OAAO,WAAW;AAAA,UAClB,MAAM,oBAAoB;AAAA,UAC1B,SAAS,EAAE,SAAS,cAAc,SAAS,eAAe;AAAA,QAC5D,CAAC;AAAA,MACH;AACA,aAAO,8BAA8B,iBAAiB,SAAS,cAAc,OAAO;AAAA,IACtF;AAAA,EACF;AAEA,SAAO,OAAO,eAAe,mBAAmB;AAEhD,MAAI,cAAc,aAAa;AAC7B,eAAW,oBAAoB,cAAc,aAAa;AACxD,aAAO,OAAO,kBAAkB,mBAAmB;AAAA,IACrD;AAAA,EACF;AAEA,QAAM,MAAM,CAAC,iBAAoC,UAAU,cAAc,aAAa;AACtF,QAAM,WAAW,CAAC,iBAAoC,eAAe,cAAc,aAAa;AAEhG,SAAO,OAAO,OAAO,eAAe,EAAE,WAAW,SAAS,cAAc,KAAK,SAAS,CAAC;AAGzF;",
+  "names": []
+}

package/lib/esm/definitions/define-options.js

@@ -1,2 +1,10 @@
-import{prepareDefinitionTypes}from"../utilities.js";function defineOptions(e){return prepareDefinitionTypes(e),e}export{defineOptions};
-//# sourceMappingURL=define-options.js.map
+// src/definitions/define-options.ts
+import { prepareDefinitionTypes } from "../utilities/schema-utilities.js";
+function defineOptions(options) {
+  prepareDefinitionTypes(options);
+  return options;
+}
+export {
+  defineOptions
+};
+//# sourceMappingURL=define-options.js.map

package/lib/esm/definitions/define-options.js.map

@@ -1 +1,7 @@
-{"version":3,"names":["prepareDefinitionTypes","defineOptions","options"],"sources":["../../../src/definitions/define-options.ts"],"sourcesContent":["import { prepareDefinitionTypes } from \"../utilities.ts\";\n\nimport type { Option } from \"../types/definitions-types.ts\";\n\nexport function defineOptions<T extends Record<string, Option>>(options: {\n  [K in keyof T]: T[K] & Option<T[K][\"schema\"]>;\n}): {\n  [K in keyof T]: Option<T[K][\"schema\"]>;\n} {\n  prepareDefinitionTypes(options);\n  return options;\n}\n"],"mappings":"OAASA,2BAA8B,kBAIhC,SAASC,cAAgDC,GAM9D,OADAF,uBAAuBE,GAChBA,CACT,Q","ignoreList":[]}
+{
+  "version": 3,
+  "sources": ["../../../src/definitions/define-options.ts"],
+  "sourcesContent": ["import { prepareDefinitionTypes } from \"../utilities/schema-utilities.ts\";\n\nimport type { Option } from \"../types/definitions-types.ts\";\n\nexport function defineOptions<T extends Record<string, Option>>(options: {\n  [K in keyof T]: T[K] & Option<T[K][\"schema\"]>;\n}): {\n  [K in keyof T]: Option<T[K][\"schema\"]>;\n} {\n  prepareDefinitionTypes(options);\n  return options;\n}\n"],
+  "mappings": ";AAAA,SAAS,8BAA8B;AAIhC,SAAS,cAAgD,SAI9D;AACA,yBAAuB,OAAO;AAC9B,SAAO;AACT;",
+  "names": []
+}

package/lib/esm/definitions/define-subcommand.js

@@ -1,2 +1,56 @@
-import{buildObjectContext}from"../parse/context/object-context-builder.js";import{validate}from"../parse/validation/validate-context.js";import{prepareDefinitionTypes}from"../utilities.js";function defineSubcommand(e){const t=e;prepareDefinitionTypes(t.options),prepareDefinitionTypes(t.arguments);return Object.assign(t,{onExecute:e=>(t._onExecute??(t._onExecute=[]),t._onExecute.push(e),()=>{const o=t._onExecute?.indexOf(e);!o||o<0||t._onExecute?.splice(o,1)}),execute:e=>{if(e??(e={}),!t._onExecute)throw new Error("Action is not defined");const o=buildObjectContext(e,t),n=validate(o,t);if(t._onExecute)for(const e of t._onExecute)e(n)}})}export{defineSubcommand};
-//# sourceMappingURL=define-subcommand.js.map
+// src/definitions/define-subcommand.ts
+import { CliError } from "../cli-error/cli-error.js";
+import { ErrorCause } from "../cli-error/error-cause.js";
+import { DefinitionErrorCode } from "../cli-error/error-code/definition-error-code.js";
+import { buildObjectContext } from "../parse/context/object-context-builder.js";
+import { validate } from "../parse/validation/validate-context.js";
+import { prepareDefinitionTypes } from "../utilities/schema-utilities.js";
+function defineSubcommand(input) {
+  const subcommandDefinition = input;
+  prepareDefinitionTypes(subcommandDefinition.options);
+  prepareDefinitionTypes(subcommandDefinition.arguments);
+  const onExecute = (handler) => {
+    subcommandDefinition._onExecute ??= [];
+    subcommandDefinition._onExecute.push(handler);
+    return () => {
+      const handlerIndex = subcommandDefinition._onExecute?.indexOf(handler);
+      if (!handlerIndex || handlerIndex < 0) return;
+      subcommandDefinition._onExecute?.splice(handlerIndex, 1);
+    };
+  };
+  const execute = (inputValues) => {
+    inputValues ??= {};
+    const handlers = subcommandDefinition._onExecute;
+    if (!handlers) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.MissingOnExecute,
+        context: { commandKind: "subcommand", commandName: subcommandDefinition.name }
+      });
+    }
+    const context = buildObjectContext(inputValues, subcommandDefinition);
+    const validateResult = validate(context, subcommandDefinition);
+    for (const handler of handlers) {
+      void handler(validateResult);
+    }
+  };
+  const executeAsync = async (inputValues) => {
+    inputValues ??= {};
+    const handlers = subcommandDefinition._onExecute;
+    if (!handlers) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.MissingOnExecute,
+        context: { commandKind: "subcommand", commandName: subcommandDefinition.name }
+      });
+    }
+    const context = buildObjectContext(inputValues, subcommandDefinition);
+    const validateResult = validate(context, subcommandDefinition);
+    await Promise.all(handlers.map(async (handler) => await handler(validateResult)));
+  };
+  return Object.assign(subcommandDefinition, { onExecute, execute, executeAsync });
+}
+export {
+  defineSubcommand
+};
+//# sourceMappingURL=define-subcommand.js.map

package/lib/esm/definitions/define-subcommand.js.map

@@ -1 +1,7 @@
-{"version":3,"names":["buildObjectContext","validate","prepareDefinitionTypes","defineSubcommand","input","subcommandSchema","options","arguments","Object","assign","onExecute","handler","_onExecute","push","handlerIndex","indexOf","splice","execute","inputValues","Error","context","validateResult"],"sources":["../../../src/definitions/define-subcommand.ts"],"sourcesContent":["import { buildObjectContext } from \"../parse/context/object-context-builder.ts\";\nimport { validate } from \"../parse/validation/validate-context.ts\";\nimport { prepareDefinitionTypes } from \"../utilities.ts\";\n\nimport type { Argument, Option, Subcommand } from \"../types/definitions-types.ts\";\nimport type { AttachedMethods, AttachedMethodsWide } from \"../types/types.ts\";\nimport type { Prettify } from \"../types/utilities-types.ts\";\n\ntype OptionsInput<T> =\n  T extends Record<string, Option> ? { [OptionName in keyof T]: Option<T[OptionName][\"schema\"]> } : T;\n\ntype ArgumentsInput<T> =\n  T extends Record<string, Argument> ? { [ArgumentName in keyof T]: Argument<T[ArgumentName][\"schema\"]> } : T;\n\n// This will prevent extra keys and enable jsdoc on hover\ntype SubcommandInput<T extends Subcommand> = {\n  [K in keyof T]: K extends keyof Subcommand\n    ? K extends \"options\"\n      ? OptionsInput<T[K]>\n      : K extends \"arguments\"\n        ? ArgumentsInput<T[K]>\n        : T[K]\n    : never;\n};\n\nexport function defineSubcommand<T extends Subcommand>(input: SubcommandInput<T> & Subcommand) {\n  const subcommandSchema = input as Prettify<T & AttachedMethods<T>>;\n\n  prepareDefinitionTypes(subcommandSchema.options);\n  prepareDefinitionTypes(subcommandSchema.arguments);\n\n  const onExecute = (handler: (Subcommand[\"_onExecute\"] & {})[number]) => {\n    subcommandSchema._onExecute ??= [];\n    subcommandSchema._onExecute.push(handler);\n\n    return () => {\n      const handlerIndex = subcommandSchema._onExecute?.indexOf(handler);\n      if (!handlerIndex || handlerIndex < 0) return;\n      subcommandSchema._onExecute?.splice(handlerIndex, 1);\n    };\n  };\n\n  const execute: AttachedMethodsWide[\"execute\"] = inputValues => {\n    inputValues ??= {};\n    if (!subcommandSchema._onExecute) throw new Error(\"Action is not defined\");\n    const context = buildObjectContext(inputValues, subcommandSchema);\n    const validateResult = validate(context, subcommandSchema);\n\n    if (subcommandSchema._onExecute) {\n      for (const handler of subcommandSchema._onExecute) {\n        handler(validateResult);\n      }\n    }\n  };\n\n  return Object.assign(subcommandSchema, { onExecute, execute });\n}\n"],"mappings":"OAASA,uBAA0B,oDAC1BC,aAAgB,iDAChBC,2BAA8B,kBAuBhC,SAASC,iBAAuCC,GACrD,MAAMC,EAAmBD,EAEzBF,uBAAuBG,EAAiBC,SACxCJ,uBAAuBG,EAAiBE,WA0BxC,OAAOC,OAAOC,OAAOJ,EAAkB,CAAEK,UAxBtBC,IACjBN,EAAiBO,aAAjBP,EAAiBO,WAAe,IAChCP,EAAiBO,WAAWC,KAAKF,GAE1B,KACL,MAAMG,EAAeT,EAAiBO,YAAYG,QAAQJ,IACrDG,GAAgBA,EAAe,GACpCT,EAAiBO,YAAYI,OAAOF,EAAc,KAiBFG,QAbJC,IAE9C,GADAA,MAAgB,CAAC,IACZb,EAAiBO,WAAY,MAAM,IAAIO,MAAM,yBAClD,MAAMC,EAAUpB,mBAAmBkB,EAAab,GAC1CgB,EAAiBpB,SAASmB,EAASf,GAEzC,GAAIA,EAAiBO,WACnB,UAAWD,KAAWN,EAAiBO,WACrCD,EAAQU,KAMhB,Q","ignoreList":[]}
+{
+  "version": 3,
+  "sources": ["../../../src/definitions/define-subcommand.ts"],
+  "sourcesContent": ["import { CliError } from \"../cli-error/cli-error.ts\";\nimport { ErrorCause } from \"../cli-error/error-cause.ts\";\nimport { DefinitionErrorCode } from \"../cli-error/error-code/definition-error-code.ts\";\nimport { buildObjectContext } from \"../parse/context/object-context-builder.ts\";\nimport { validate } from \"../parse/validation/validate-context.ts\";\nimport { prepareDefinitionTypes } from \"../utilities/schema-utilities.ts\";\n\nimport type { Argument, Option, Subcommand } from \"../types/definitions-types.ts\";\nimport type { AttachedMethods, AttachedMethodsWide } from \"../types/types.ts\";\nimport type { Prettify } from \"../types/utilities-types.ts\";\n\ntype OptionsInput<T> =\n  T extends Record<string, Option> ? { [OptionName in keyof T]: Option<T[OptionName][\"schema\"]> } : T;\n\ntype ArgumentsInput<T> =\n  T extends Record<string, Argument> ? { [ArgumentName in keyof T]: Argument<T[ArgumentName][\"schema\"]> } : T;\n\n// This will prevent extra keys and enable jsdoc on hover\ntype SubcommandInput<T extends Subcommand> = {\n  [K in keyof T]: K extends keyof Subcommand\n    ? K extends \"options\"\n      ? OptionsInput<T[K]>\n      : K extends \"arguments\"\n        ? ArgumentsInput<T[K]>\n        : T[K]\n    : never;\n};\n\nexport function defineSubcommand<T extends Subcommand>(input: SubcommandInput<T> & Subcommand) {\n  const subcommandDefinition = input as T;\n\n  prepareDefinitionTypes(subcommandDefinition.options);\n  prepareDefinitionTypes(subcommandDefinition.arguments);\n\n  const onExecute = (handler: (Subcommand[\"_onExecute\"] & {})[number]) => {\n    subcommandDefinition._onExecute ??= [];\n    subcommandDefinition._onExecute.push(handler);\n\n    return () => {\n      const handlerIndex = subcommandDefinition._onExecute?.indexOf(handler);\n      if (!handlerIndex || handlerIndex < 0) return;\n      subcommandDefinition._onExecute?.splice(handlerIndex, 1);\n    };\n  };\n\n  const execute: AttachedMethodsWide[\"execute\"] = inputValues => {\n    inputValues ??= {};\n\n    const handlers = subcommandDefinition._onExecute;\n\n    if (!handlers) {\n      throw new CliError({\n        cause: ErrorCause.Definition,\n        code: DefinitionErrorCode.MissingOnExecute,\n        context: { commandKind: \"subcommand\", commandName: subcommandDefinition.name },\n      });\n    }\n\n    const context = buildObjectContext(inputValues, subcommandDefinition);\n    const validateResult = validate(context, subcommandDefinition);\n\n    for (const handler of handlers) {\n      void handler(validateResult);\n    }\n  };\n\n  const executeAsync: AttachedMethodsWide[\"executeAsync\"] = async inputValues => {\n    inputValues ??= {};\n\n    const handlers = subcommandDefinition._onExecute;\n\n    if (!handlers) {\n      throw new CliError({\n        cause: ErrorCause.Definition,\n        code: DefinitionErrorCode.MissingOnExecute,\n        context: { commandKind: \"subcommand\", commandName: subcommandDefinition.name },\n      });\n    }\n\n    const context = buildObjectContext(inputValues, subcommandDefinition);\n    const validateResult = validate(context, subcommandDefinition);\n\n    await Promise.all(handlers.map(async handler => await handler(validateResult)));\n  };\n\n  return Object.assign(subcommandDefinition, { onExecute, execute, executeAsync }) as Prettify<T & AttachedMethods<T>>;\n}\n"],
+  "mappings": ";AAAA,SAAS,gBAAgB;AACzB,SAAS,kBAAkB;AAC3B,SAAS,2BAA2B;AACpC,SAAS,0BAA0B;AACnC,SAAS,gBAAgB;AACzB,SAAS,8BAA8B;AAuBhC,SAAS,iBAAuC,OAAwC;AAC7F,QAAM,uBAAuB;AAE7B,yBAAuB,qBAAqB,OAAO;AACnD,yBAAuB,qBAAqB,SAAS;AAErD,QAAM,YAAY,CAAC,YAAqD;AACtE,yBAAqB,eAAe,CAAC;AACrC,yBAAqB,WAAW,KAAK,OAAO;AAE5C,WAAO,MAAM;AACX,YAAM,eAAe,qBAAqB,YAAY,QAAQ,OAAO;AACrE,UAAI,CAAC,gBAAgB,eAAe,EAAG;AACvC,2BAAqB,YAAY,OAAO,cAAc,CAAC;AAAA,IACzD;AAAA,EACF;AAEA,QAAM,UAA0C,iBAAe;AAC7D,oBAAgB,CAAC;AAEjB,UAAM,WAAW,qBAAqB;AAEtC,QAAI,CAAC,UAAU;AACb,YAAM,IAAI,SAAS;AAAA,QACjB,OAAO,WAAW;AAAA,QAClB,MAAM,oBAAoB;AAAA,QAC1B,SAAS,EAAE,aAAa,cAAc,aAAa,qBAAqB,KAAK;AAAA,MAC/E,CAAC;AAAA,IACH;AAEA,UAAM,UAAU,mBAAmB,aAAa,oBAAoB;AACpE,UAAM,iBAAiB,SAAS,SAAS,oBAAoB;AAE7D,eAAW,WAAW,UAAU;AAC9B,WAAK,QAAQ,cAAc;AAAA,IAC7B;AAAA,EACF;AAEA,QAAM,eAAoD,OAAM,gBAAe;AAC7E,oBAAgB,CAAC;AAEjB,UAAM,WAAW,qBAAqB;AAEtC,QAAI,CAAC,UAAU;AACb,YAAM,IAAI,SAAS;AAAA,QACjB,OAAO,WAAW;AAAA,QAClB,MAAM,oBAAoB;AAAA,QAC1B,SAAS,EAAE,aAAa,cAAc,aAAa,qBAAqB,KAAK;AAAA,MAC/E,CAAC;AAAA,IACH;AAEA,UAAM,UAAU,mBAAmB,aAAa,oBAAoB;AACpE,UAAM,iBAAiB,SAAS,SAAS,oBAAoB;AAE7D,UAAM,QAAQ,IAAI,SAAS,IAAI,OAAM,YAAW,MAAM,QAAQ,cAAc,CAAC,CAAC;AAAA,EAChF;AAEA,SAAO,OAAO,OAAO,sBAAsB,EAAE,WAAW,SAAS,aAAa,CAAC;AACjF;",
+  "names": []
+}

package/lib/esm/definitions/validate-cli-definition.js

@@ -1,2 +1,360 @@
-import{transformOptionToArgument}from"../parse/parser-utilities.js";import{findDuplicateStrings}from"../utilities.js";function validateCliDefinition(t){if(!t.cliName)throw new Error('invalid cli definition: "cliName" property is required.');validateOptions(t),validateArguments(t);const i=t.subcommands;if(!i)return;if(0===i.length)throw new Error(`invalid cli definition "${t.cliName}": "subcommands" property is optional but cannot be empty.`);const n=i.map(t=>t.name);if(n.some(t=>!t))throw new Error('invalid subcommand definition: subcommand\'s "name" property is required.');const e=findDuplicateStrings(n).map(t=>`"${t}"`);if(e.length>0)throw new Error(`invalid cli definition "${t.cliName}" has duplicated subcommands: ${e.join(", ")}.`);for(const t of i){if(t.aliases){const e=findDuplicateStrings(t.aliases).map(t=>`"${t}"`);if(e.length>0)throw new Error(`subcommand "${t.name}" has duplicated aliases: ${e.join(", ")}.`);for(const e of t.aliases){if(""===e)throw new Error(`subcommand "${t.name}" has an empty string alias.`);if(n.includes(e))throw new Error(`subcommand "${t.name}" alias "${e}" conflicts with another subcommand name.`);const o=i.filter(i=>i.name!==t.name&&i.aliases?.includes(e));if(o.length>0)throw new Error(`subcommand "${t.name}" alias "${e}" conflicts with another subcommand alias: "${o[0].name}".`)}}validateOptions(t),validateArguments(t)}}function validateOptions(t){if(!t.options)return;const i="cliName"in t,n=i?t.cliName:t.name,e=t=>new Error(`invalid ${i?"cli":"subcommand"} definition "${n}": ${t}`),o=Object.entries(t.options);if(0===o.length)throw e('"options" property is optional but cannot be empty.');for(const[i,n]of o){if(!n.schema)throw e(`the option "${i}" missing a required property: "schema".`);if(!n._preparedType)throw e(`internal error: missing prepared type for option "${i}".`);if(isNegatedOptionName(i))throw e(`the option "${i}" is a negated option name.`);if(t.arguments&&i in t.arguments)throw e(`the option "${i}" name conflicts with an argument name.`);if(n.aliases){const r=findDuplicateStrings(n.aliases);if(r.length>0)throw e(`the option "${i}" has duplicated aliases: ${r.join(", ")}.`);for(const r of n.aliases){if(""===r)throw e(`the option "${i}" has an empty string alias.`);if(isNegatedOptionName(r))throw e(`the alias "${r}" of the option "${i}" is a negated option name.`);if(t.options[r])throw e(`the alias "${r}" of the option "${i}" conflicts with another option name.`);if(t.arguments&&r in t.arguments)throw e(`the alias "${r}" of the option "${i}" conflicts with an argument name.`);const n=o.find(([t,n])=>t!==i&&n.aliases?.includes(r));if(n)throw e(`the alias "${r}" of the option "${i}" conflicts with another alias name of the option "${n[0]}".`)}}if(n.requires){if(n.requires.includes(i))throw e(`the option "${i}" cannot require itself.`);const o=findDuplicateStrings(n.requires).map(t=>`"${t}"`);if(o.length>0)throw e(`the option "${i}" has duplicate requires: ${o.join(", ")}.`);for(const o of n.requires){if(!(o in t.options||o in(t.arguments??[])))throw e(`the option "${i}" requires "${o}", but it does not exist.`)}}if(n.conflictWith){if(n.conflictWith.includes(i))throw e(`the option "${i}" cannot conflict itself.`);const o=findDuplicateStrings(n.conflictWith).map(t=>`"${t}"`);if(o.length>0)throw e(`the option "${i}" has duplicate conflicts: ${o.join(", ")}.`);for(const o of n.conflictWith){if(!(o in t.options||o in(t.arguments??[])))throw e(`the option "${i}" conflict with "${o}", but it does not exist.`)}}if(n.requires&&n.conflictWith){const t=new Set(n.requires),o=new Set(n.conflictWith),r=t.intersection(o),a=Array.from(r).map(t=>`"${t}"`);if(a.length>0){const t=a.length>1?"s":"";throw e(`the option "${i}" cannot require and conflict with the same name${t}: ${a.join(", ")}.`)}}}}function validateArguments(t){if(!t.arguments)return;const i="cliName"in t,n=i?t.cliName:t.name,e=t=>new Error(`invalid ${i?"cli":"subcommand"} definition "${n}": ${t}`);if(t.arguments){const i=Object.entries(t.arguments);if(0===i.length)throw e('"arguments" property is optional but cannot be empty.');for(const[n,[o,r]]of i.entries()){if(/^\d+$/.test(o))throw e(`the argument "${o}" name cannot be a number.`);if(!r._preparedType)throw e(`internal error: missing prepared type for argument "${o}".`);if(!r.schema)throw e(`the argument "${o}" missing a required property: "schema".`);if(t.options&&o in t.options)throw e(`the argument "${o}" name conflicts with an option name.`);if(r._preparedType.optional){if(t.allowPositionals)throw e(`the argument "${o}" cannot be optional when "allowPositionals" is enabled.`);if(n!==i.length-1)throw e(`the argument "${o}" cannot be optional unless it is the last argument.`);if(r.requires){if(r.requires.includes(o))throw e(`the argument "${o}" cannot require itself.`);const i=findDuplicateStrings(r.requires).map(t=>`"${t}"`);if(i.length>0)throw e(`the argument "${o}" has duplicate requires: ${i.join(", ")}.`);for(const i of r.requires){if(!(i in(t.options??{})||i in t.arguments))throw e(`the argument "${o}" requires "${i}", but it does not exist.`)}}if(r.conflictWith){if(r.conflictWith.includes(o))throw e(`the argument "${o}" cannot conflict itself.`);const i=findDuplicateStrings(r.conflictWith).map(t=>`"${t}"`);if(i.length>0)throw e(`the argument "${o}" has duplicate conflicts: ${i.join(", ")}.`);for(const i of r.conflictWith){if(!(i in(t.options??{})||i in t.arguments))throw e(`the argument "${o}" conflict with "${i}", but it does not exist.`)}}if(r.requires&&r.conflictWith){const t=new Set(r.requires),i=new Set(r.conflictWith),n=t.intersection(i),a=Array.from(n).map(t=>`"${t}"`);if(a.length>0){throw e(`the argument "${o}" cannot require and conflict with the same name${a.length>1?"s":""}: ${a.join(", ")}.`)}}}}}}function isNegatedOptionName(t){return transformOptionToArgument(t).startsWith("--no-")}export{validateCliDefinition};
-//# sourceMappingURL=validate-cli-definition.js.map
+// src/definitions/validate-cli-definition.ts
+import { CliError } from "../cli-error/cli-error.js";
+import { ErrorCause } from "../cli-error/error-cause.js";
+import { DefinitionErrorCode } from "../cli-error/error-code/definition-error-code.js";
+import { InternalErrorCode } from "../cli-error/error-code/internal-error-code.js";
+import { transformOptionToArgument } from "../parse/parser-utilities.js";
+function validateCliDefinition(cliDefinition) {
+  if (!cliDefinition.cliName) {
+    throw new CliError({
+      cause: ErrorCause.Definition,
+      code: DefinitionErrorCode.MissingDefinitionName,
+      context: { commandKind: "command" }
+    });
+  }
+  validateOptions(cliDefinition);
+  validateArguments(cliDefinition);
+  const subcommands = cliDefinition.subcommands;
+  if (!subcommands) return;
+  if (subcommands.length === 0) {
+    throw new CliError({
+      cause: ErrorCause.Definition,
+      code: DefinitionErrorCode.EmptyDefinitionGroup,
+      context: { commandKind: "command", commandName: cliDefinition.cliName, kind: "subcommands" }
+    });
+  }
+  const commandsNames = new Set(subcommands.map((c) => c.name));
+  const visitedSubcommandNames = /* @__PURE__ */ new Set();
+  for (const subcommand of subcommands) {
+    if (!subcommand.name) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.MissingDefinitionName,
+        context: { commandKind: "subcommand" }
+      });
+    }
+    if (visitedSubcommandNames.has(subcommand.name)) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.DuplicateDefinitionName,
+        context: {
+          commandKind: "command",
+          commandName: cliDefinition.cliName,
+          kind: "subcommand",
+          name: subcommand.name,
+          foundInKind: "subcommand"
+        }
+      });
+    }
+    visitedSubcommandNames.add(subcommand.name);
+    if (subcommand.aliases) {
+      for (const alias of subcommand.aliases) {
+        if (alias === "") {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.EmptyStringAliasName,
+            context: { commandKind: "subcommand", commandName: subcommand.name }
+          });
+        }
+        if (commandsNames.has(alias)) {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.DuplicateDefinitionName,
+            context: {
+              commandKind: "command",
+              commandName: cliDefinition.cliName,
+              kind: "subcommand",
+              name: subcommand.name,
+              foundInKind: "subcommand",
+              duplicatedAlias: alias
+            }
+          });
+        }
+        const aliasConflicts = subcommands.filter((c) => c.name !== subcommand.name && c.aliases?.includes(alias));
+        if (aliasConflicts.length > 0) {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.DuplicateDefinitionName,
+            context: {
+              commandKind: "command",
+              commandName: cliDefinition.cliName,
+              kind: "subcommand",
+              name: subcommand.name,
+              foundInKind: "subcommand",
+              duplicatedAlias: alias,
+              foundInName: aliasConflicts[0].name
+            }
+          });
+        }
+      }
+    }
+    validateOptions(subcommand);
+    validateArguments(subcommand);
+  }
+}
+function validateOptions(commandDefinition) {
+  if (!commandDefinition.options) return;
+  const isCli = "cliName" in commandDefinition;
+  const commandName = isCli ? commandDefinition.cliName : commandDefinition.name;
+  const commandKind = isCli ? "command" : "subcommand";
+  const optionsDefinitionEntries = Object.entries(commandDefinition.options);
+  if (optionsDefinitionEntries.length === 0) {
+    throw new CliError({
+      cause: ErrorCause.Definition,
+      code: DefinitionErrorCode.EmptyDefinitionGroup,
+      context: { commandKind, commandName, kind: "option" }
+    });
+  }
+  for (const [name, option] of optionsDefinitionEntries) {
+    if (!option.schema) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.MissingSchema,
+        context: { commandKind, commandName, kind: "option", name }
+      });
+    }
+    if (!option._preparedType) {
+      throw new CliError({
+        cause: ErrorCause.Internal,
+        code: InternalErrorCode.MissingPreparedTypes,
+        context: { commandKind, commandName, kind: "option", name }
+      });
+    }
+    if (isNegatedOptionName(name)) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.InvalidDefinitionOptionName,
+        context: { commandKind, commandName, optionName: name }
+      });
+    }
+    if (commandDefinition.arguments && name in commandDefinition.arguments) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.DuplicateDefinitionName,
+        context: { commandKind, commandName, kind: "option", name, foundInKind: "argument" }
+      });
+    }
+    if (option.aliases) {
+      for (const aliasName of option.aliases) {
+        if (aliasName === "") {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.EmptyStringAliasName,
+            context: { commandKind, commandName, optionName: name }
+          });
+        }
+        if (isNegatedOptionName(aliasName)) {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.InvalidDefinitionOptionName,
+            context: { commandKind, commandName, optionName: name, negatedAliasName: aliasName }
+          });
+        }
+        if (commandDefinition.options[aliasName]) {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.DuplicateDefinitionName,
+            context: {
+              commandKind,
+              commandName,
+              kind: "option",
+              name,
+              duplicatedAlias: aliasName,
+              foundInKind: "option"
+            }
+          });
+        }
+        if (commandDefinition.arguments && aliasName in commandDefinition.arguments) {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.DuplicateDefinitionName,
+            context: {
+              commandKind,
+              commandName,
+              kind: "option",
+              name,
+              duplicatedAlias: aliasName,
+              foundInKind: "argument"
+            }
+          });
+        }
+        const findConflict = optionsDefinitionEntries.find(([n, d]) => n !== name && d.aliases?.includes(aliasName));
+        if (findConflict) {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.DuplicateDefinitionName,
+            context: {
+              commandKind,
+              commandName,
+              kind: "option",
+              name: aliasName,
+              foundInKind: "option",
+              foundInName: findConflict[0]
+            }
+          });
+        }
+      }
+    }
+    if (option.requires) {
+      if (option.requires.includes(name)) {
+        throw new CliError({
+          cause: ErrorCause.Definition,
+          code: DefinitionErrorCode.SelfRequire,
+          context: { commandKind, commandName, kind: "option", name }
+        });
+      }
+      for (const requiredName of option.requires) {
+        const exits = requiredName in commandDefinition.options || requiredName in (commandDefinition.arguments ?? []);
+        if (!exits) {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.UnknownRequireName,
+            context: { commandKind, commandName, kind: "option", name, requiredName }
+          });
+        }
+      }
+    }
+    if (option.conflictWith) {
+      if (option.conflictWith.includes(name)) {
+        throw new CliError({
+          cause: ErrorCause.Definition,
+          code: DefinitionErrorCode.SelfConflict,
+          context: { commandKind, commandName, kind: "option", name }
+        });
+      }
+      for (const requiredName of option.conflictWith) {
+        const exits = requiredName in commandDefinition.options || requiredName in (commandDefinition.arguments ?? []);
+        if (!exits) {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.UnknownConflictName,
+            context: { commandKind, commandName, kind: "option", name, requiredName }
+          });
+        }
+      }
+    }
+    if (option.requires && option.conflictWith) {
+      const requiresSet = new Set(option.requires);
+      const conflictsSet = new Set(option.conflictWith);
+      const intersection = requiresSet.intersection(conflictsSet);
+      const intersectedNames = Array.from(intersection).map((name2) => `"${name2}"`);
+      if (intersectedNames.length > 0) {
+        throw new CliError({
+          cause: ErrorCause.Definition,
+          code: DefinitionErrorCode.DefinitionRequiresConflictOverlap,
+          context: { commandKind, commandName, kind: "option", name, intersectedNames }
+        });
+      }
+    }
+  }
+}
+function validateArguments(commandDefinition) {
+  if (!commandDefinition.arguments) return;
+  const isCli = "cliName" in commandDefinition;
+  const commandName = isCli ? commandDefinition.cliName : commandDefinition.name;
+  const commandKind = isCli ? "command" : "subcommand";
+  const argumentsDefinitionEntries = Object.entries(commandDefinition.arguments);
+  if (argumentsDefinitionEntries.length === 0) {
+    throw new CliError({
+      cause: ErrorCause.Definition,
+      code: DefinitionErrorCode.EmptyDefinitionGroup,
+      context: { commandKind, commandName, kind: "argument" }
+    });
+  }
+  for (const [index, [name, argument]] of argumentsDefinitionEntries.entries()) {
+    if (/^\d+$/.test(name)) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.InvalidDefinitionArgumentName,
+        context: { commandKind, commandName, name }
+      });
+    }
+    if (!argument._preparedType) {
+      throw new CliError({
+        cause: ErrorCause.Internal,
+        code: InternalErrorCode.MissingPreparedTypes,
+        context: { commandKind, commandName, kind: "argument", name }
+      });
+    }
+    if (!argument.schema) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.MissingSchema,
+        context: { commandKind, commandName, kind: "argument", name }
+      });
+    }
+    if (!argument._preparedType.optional) continue;
+    if (commandDefinition.allowPositionals) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.InvalidOptionalArgumentDefinition,
+        context: { commandKind, commandName, name, allowPositionals: true }
+      });
+    }
+    if (index !== argumentsDefinitionEntries.length - 1) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.InvalidOptionalArgumentDefinition,
+        context: { commandKind, commandName, name, allowPositionals: false }
+      });
+    }
+    if (argument.requires) {
+      if (argument.requires.includes(name)) {
+        throw new CliError({
+          cause: ErrorCause.Definition,
+          code: DefinitionErrorCode.SelfRequire,
+          context: { commandKind, commandName, kind: "argument", name }
+        });
+      }
+      for (const requiredName of argument.requires) {
+        const exits = requiredName in (commandDefinition.options ?? {}) || requiredName in commandDefinition.arguments;
+        if (!exits) {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.UnknownRequireName,
+            context: { commandKind, commandName, kind: "argument", name, requiredName }
+          });
+        }
+      }
+    }
+    if (argument.conflictWith) {
+      if (argument.conflictWith.includes(name)) {
+        throw new CliError({
+          cause: ErrorCause.Definition,
+          code: DefinitionErrorCode.SelfConflict,
+          context: { commandKind, commandName, kind: "argument", name }
+        });
+      }
+      for (const requiredName of argument.conflictWith) {
+        const exits = requiredName in (commandDefinition.options ?? {}) || requiredName in commandDefinition.arguments;
+        if (!exits) {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.UnknownConflictName,
+            context: { commandKind, commandName, kind: "argument", name, requiredName }
+          });
+        }
+      }
+    }
+    if (argument.requires && argument.conflictWith) {
+      const requiresSet = new Set(argument.requires);
+      const conflictsSet = new Set(argument.conflictWith);
+      const intersection = requiresSet.intersection(conflictsSet);
+      const intersectedNames = Array.from(intersection).map((name2) => `"${name2}"`);
+      if (intersectedNames.length > 0) {
+        throw new CliError({
+          cause: ErrorCause.Definition,
+          code: DefinitionErrorCode.DefinitionRequiresConflictOverlap,
+          context: { commandKind, commandName, kind: "argument", name, intersectedNames }
+        });
+      }
+    }
+  }
+}
+function isNegatedOptionName(name) {
+  return transformOptionToArgument(name).startsWith("--no-");
+}
+export {
+  validateCliDefinition
+};
+//# sourceMappingURL=validate-cli-definition.js.map