massarg 2.0.0-pre.1 → 2.0.0-pre.11

package/option.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
-export declare const OptionConfig: <T extends z.ZodType<any, z.ZodTypeDef, any>>(type: T) => z.ZodObject<{
+import { ArgsObject } from './command';
+export declare const OptionConfig: <OptionType, Args extends ArgsObject = ArgsObject>(type: z.ZodType<OptionType, z.ZodTypeDef, OptionType>) => z.ZodObject<{
     /** Name of the option */
     name: z.ZodString;
     /** Description of the option, displayed in the help output */
@@ -12,7 +13,7 @@ export declare const OptionConfig: <T extends z.ZodType<any, z.ZodTypeDef, any>>
      * Parse the value of the option. You can return any type here, or throw an error if the value
      * is invalid.
      */
-    parse: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, T>>;
+    parse: z.ZodOptional<z.ZodType<Parser<Args, OptionType>, z.ZodTypeDef, Parser<Args, OptionType>>>;
     /**
      * Whether the option is an array.
      *
@@ -37,107 +38,153 @@ export declare const OptionConfig: <T extends z.ZodType<any, z.ZodTypeDef, any>>
     /** Specify a custom name for the output, which will be used when parsing the args. */
     outputName: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    description: string;
     name: string;
+    description: string;
     aliases: string[];
     defaultValue?: any;
-    parse?: ((args_0: string, ...args_1: unknown[]) => T["_output"]) | undefined;
+    parse?: Parser<Args, OptionType> | undefined;
     array?: boolean | undefined;
     required?: boolean | undefined;
     isDefault?: boolean | undefined;
     hidden?: boolean | undefined;
     outputName?: string | undefined;
 }, {
-    description: string;
     name: string;
+    description: string;
     aliases: string[];
     defaultValue?: any;
-    parse?: ((args_0: string, ...args_1: unknown[]) => T["_input"]) | undefined;
+    parse?: Parser<Args, OptionType> | undefined;
     array?: boolean | undefined;
     required?: boolean | undefined;
     isDefault?: boolean | undefined;
     hidden?: boolean | undefined;
     outputName?: string | undefined;
 }>;
-export type OptionConfig<T = unknown> = z.infer<ReturnType<typeof OptionConfig<z.ZodType<T>>>>;
-export declare const TypedOptionConfig: <T extends z.ZodType<any, z.ZodTypeDef, any>>(type: T) => z.ZodObject<{
-    array: z.ZodOptional<z.ZodBoolean>;
+export type OptionConfig<T = unknown, Args extends ArgsObject = ArgsObject> = z.infer<ReturnType<typeof OptionConfig<T, Args>>>;
+/**
+ * Configuration for a flag (boolean argument) that can be passed to a command.
+ */
+export declare const FlagConfig: z.ZodObject<{
+    name: z.ZodString;
     description: z.ZodString;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    aliases: z.ZodArray<z.ZodString, "many">;
+    array: z.ZodOptional<z.ZodBoolean>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    outputName: z.ZodOptional<z.ZodString>;
+    negatable: z.ZodOptional<z.ZodBoolean>;
+    negationName: z.ZodOptional<z.ZodString>;
+    negationAliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    aliases: string[];
+    defaultValue?: any;
+    array?: boolean | undefined;
+    required?: boolean | undefined;
+    hidden?: boolean | undefined;
+    outputName?: string | undefined;
+    negatable?: boolean | undefined;
+    negationName?: string | undefined;
+    negationAliases?: string[] | undefined;
+}, {
+    name: string;
+    description: string;
+    aliases: string[];
+    defaultValue?: any;
+    array?: boolean | undefined;
+    required?: boolean | undefined;
+    hidden?: boolean | undefined;
+    outputName?: string | undefined;
+    negatable?: boolean | undefined;
+    negationName?: string | undefined;
+    negationAliases?: string[] | undefined;
+}>;
+export type FlagConfig = z.infer<typeof FlagConfig>;
+/**
+ * A function that parses an option value.
+ */
+export type Parser<Args extends ArgsObject = ArgsObject, OptionType extends any = any> = (x: string, y: Args) => OptionType;
+/** {@link OptionConfig} with a specified value type */
+export declare const TypedOptionConfig: <OptionType, Args extends ArgsObject = ArgsObject>(type: z.ZodType<OptionType, z.ZodTypeDef, OptionType>) => z.ZodObject<{
     name: z.ZodString;
+    description: z.ZodString;
     defaultValue: z.ZodOptional<z.ZodAny>;
     aliases: z.ZodArray<z.ZodString, "many">;
-    parse: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, T>>;
+    array: z.ZodOptional<z.ZodBoolean>;
     required: z.ZodOptional<z.ZodBoolean>;
     isDefault: z.ZodOptional<z.ZodBoolean>;
     hidden: z.ZodOptional<z.ZodBoolean>;
     outputName: z.ZodOptional<z.ZodString>;
+    parse: z.ZodOptional<z.ZodType<Parser<Args, OptionType>, z.ZodTypeDef, Parser<Args, OptionType>>>;
     type: z.ZodOptional<z.ZodEnum<["number"]>>;
 }, "strip", z.ZodTypeAny, {
-    description: string;
     name: string;
+    description: string;
     aliases: string[];
-    array?: boolean | undefined;
     defaultValue?: any;
-    parse?: ((args_0: string, ...args_1: unknown[]) => T["_output"]) | undefined;
+    array?: boolean | undefined;
     required?: boolean | undefined;
     isDefault?: boolean | undefined;
     hidden?: boolean | undefined;
     outputName?: string | undefined;
+    parse?: Parser<Args, OptionType> | undefined;
     type?: "number" | undefined;
 }, {
-    description: string;
     name: string;
+    description: string;
     aliases: string[];
-    array?: boolean | undefined;
     defaultValue?: any;
-    parse?: ((args_0: string, ...args_1: unknown[]) => T["_input"]) | undefined;
+    array?: boolean | undefined;
     required?: boolean | undefined;
     isDefault?: boolean | undefined;
     hidden?: boolean | undefined;
     outputName?: string | undefined;
+    parse?: Parser<Args, OptionType> | undefined;
     type?: "number" | undefined;
 }>;
-export type TypedOptionConfig<T = unknown> = z.infer<ReturnType<typeof TypedOptionConfig<z.ZodType<T>>>>;
+export type TypedOptionConfig<T, A extends ArgsObject = ArgsObject> = z.infer<ReturnType<typeof TypedOptionConfig<T, A>>>;
 /**
  * @see OptionConfig
  * @see ArrayOptionConfig
  */
-export declare const ArrayOptionConfig: <T extends z.ZodType<any, z.ZodTypeDef, any>>(type: T) => z.ZodObject<{
+export declare const ArrayOptionConfig: <T, A extends ArgsObject = ArgsObject>(type: z.ZodType<T, z.ZodTypeDef, T>) => z.ZodObject<{
     type: z.ZodOptional<z.ZodEnum<["number"]>>;
-    array: z.ZodOptional<z.ZodBoolean>;
-    description: z.ZodString;
     name: z.ZodString;
+    description: z.ZodString;
     aliases: z.ZodArray<z.ZodString, "many">;
-    parse: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodArray<T, "many">>>;
+    array: z.ZodOptional<z.ZodBoolean>;
     required: z.ZodOptional<z.ZodBoolean>;
     isDefault: z.ZodOptional<z.ZodBoolean>;
     hidden: z.ZodOptional<z.ZodBoolean>;
     outputName: z.ZodOptional<z.ZodString>;
-    defaultValue: z.ZodOptional<z.ZodArray<T, "many">>;
+    parse: z.ZodOptional<z.ZodType<Parser<A, T[]>, z.ZodTypeDef, Parser<A, T[]>>>;
+    defaultValue: z.ZodOptional<z.ZodArray<z.ZodType<T, z.ZodTypeDef, T>, "many">>;
 }, "strip", z.ZodTypeAny, {
-    description: string;
     name: string;
+    description: string;
     aliases: string[];
     type?: "number" | undefined;
     array?: boolean | undefined;
-    parse?: ((args_0: string, ...args_1: unknown[]) => T["_output"][]) | undefined;
     required?: boolean | undefined;
     isDefault?: boolean | undefined;
     hidden?: boolean | undefined;
     outputName?: string | undefined;
-    defaultValue?: T["_output"][] | undefined;
+    parse?: Parser<A, T[]> | undefined;
+    defaultValue?: T[] | undefined;
 }, {
-    description: string;
     name: string;
+    description: string;
     aliases: string[];
     type?: "number" | undefined;
     array?: boolean | undefined;
-    parse?: ((args_0: string, ...args_1: unknown[]) => T["_input"][]) | undefined;
     required?: boolean | undefined;
     isDefault?: boolean | undefined;
     hidden?: boolean | undefined;
     outputName?: string | undefined;
-    defaultValue?: T["_input"][] | undefined;
+    parse?: Parser<A, T[]> | undefined;
+    defaultValue?: T[] | undefined;
 }>;
 /**
  * An option that can be passed to a command.
@@ -145,6 +192,25 @@ export declare const ArrayOptionConfig: <T extends z.ZodType<any, z.ZodTypeDef,
  * This type represents an array option, which can be specified multiple times.
  */
 export type ArrayOptionConfig<T = unknown> = z.infer<ReturnType<typeof ArrayOptionConfig<z.ZodType<T>>>>;
+/** The default prefixes for options */
+export declare const DEFAULT_OPT_FULL_PREFIX = "--";
+/** The default prefix for option aliases */
+export declare const DEFAULT_OPT_SHORT_PREFIX = "-";
+export type Prefixes = {
+    normalPrefix: string;
+    aliasPrefix: string;
+};
+export type Names = {
+    name: string;
+    aliases: string[];
+};
+/** Names with prefixes built-in */
+export type QualifiedNames = {
+    name: string;
+    aliases: string[];
+    negationName: string;
+    negationAliases: string[];
+};
 /** @internal */
 export type ArgvValue<T> = {
     argv: string[];
@@ -173,22 +239,43 @@ export type ArgvValue<T> = {
  * })
  * ```
  */
-export declare class MassargOption<T = unknown> {
+export declare class MassargOption<OptionType extends any = unknown, Args extends ArgsObject = ArgsObject> implements OptionConfig<OptionType, Args> {
     name: string;
     description: string;
-    defaultValue?: T;
+    defaultValue?: OptionType;
     aliases: string[];
-    parse: (value: string) => T;
+    parse: Parser<Args, OptionType>;
+    /**
+     * Whether this option can be used multiple times. Any passed values will end up in an array
+     * instead of each usage overwriting the existing value.
+     */
     isArray: boolean;
+    /** Whether this option is required. Failing to specify this option will throw an error. */
+    isRequired: boolean;
     isDefault: boolean;
     outputName?: string;
-    constructor(options: OptionConfig<T>);
-    static fromTypedConfig<T = unknown>(config: TypedOptionConfig<T>): MassargOption<T>;
-    _parseDetails(argv: string[]): ArgvValue<T>;
+    constructor(options: OptionConfig<OptionType, Args>);
+    /**
+     * Create a typed option from a configuration. Currently supports `number` options which
+     * are automatically transformed from `string` to `number`.
+     */
+    static fromTypedConfig<T = unknown, A extends ArgsObject = ArgsObject>(config: TypedOptionConfig<T, A>): MassargOption<T>;
+    /**
+     * Returns the key which this option outputs to in the final object.
+     *
+     * @default The camelCase version of this option's name.
+     *
+     * Can be overridden with {@link outputName}.
+     */
+    getOutputName(): string;
+    /** @internal */
+    parseDetails(argv: string[], options: ArgsObject, prefixes: Prefixes): ArgvValue<OptionType>;
+    /** Get the help string for this option */
     helpString(): string;
-    _match(arg: string): boolean;
-    _isOption(arg: string): boolean;
-    static getName(arg: string): string;
+    /** Returns true if the flag (including any prefixes) matches the name or aliases */
+    isMatch(arg: string, prefixes: Prefixes): boolean;
+    /** Return the finalized names that will cause this option to match. */
+    qualifiedNames(prefixes: Prefixes): QualifiedNames;
 }
 /**
  * An option that can be passed to a command.
@@ -208,18 +295,19 @@ export declare class MassargOption<T = unknown> {
  */
 export declare class MassargNumber extends MassargOption<number> {
     constructor(options: Omit<OptionConfig<number>, 'parse'>);
-    _parseDetails(argv: string[]): ArgvValue<number>;
+    parseDetails(argv: string[], options: ArgsObject, prefixes: Prefixes): ArgvValue<number>;
 }
 /**
- * An option that can be passed to a command.
+ * A boolean option that can be passed to a command.
  *
  * A flag is an option that is either present or not. It can be used to toggle
  * a boolean value, or to indicate that a command should be run in a different
  * mode.
  *
- * A flag can be negated by prefixing it with `no-`. For example, `--no-verbose`,
- * or by prefixing the alias with `^` instead of `-`. This is configurable via the command's
- * configuration.
+ * A flag can be negated by using `negatable: true`. By default, the negated name is the same
+ * as the option name, prefixed by `no-`, and each of the aliases will be uppercased.
+ * For example, `--verbose` and `--no-verbose`, or `-v` and `-V`.
+ * This behavior can be overridden by the `negatedName` and `negatedAliases` options.
  *
  * @example
  * ```ts
@@ -232,9 +320,17 @@ export declare class MassargNumber extends MassargOption<number> {
  * ```
  */
 export declare class MassargFlag extends MassargOption<boolean> {
-    constructor(options: Omit<OptionConfig<boolean>, 'parse'>);
-    _parseDetails(argv: string[]): ArgvValue<boolean>;
+    /** Whether this flag may be negated using `negationName` or `negationAliases`. */
+    negatable: boolean;
+    /** The negation name of this flag, which can be used with the full option notation. */
+    negationName: string;
+    /** The negation aliases of this flag, which can be used with the shorthand option notation. */
+    negationAliases: string[];
+    constructor(options: FlagConfig);
+    parseDetails(argv: string[], _options: ArgsObject, prefixes: Prefixes): ArgvValue<boolean>;
+    qualifiedNames(prefixes: Prefixes): QualifiedNames;
 }
+/** A flag that can be passed to a command to show the help message. */
 export declare class MassargHelpFlag extends MassargFlag {
     constructor(config?: Partial<Omit<OptionConfig<boolean>, 'parse'>>);
 }

package/option.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"option.d.ts","sourceRoot":"","sources":["../src/option.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"option.d.ts","sourceRoot":"","sources":["../src/option.ts"],"names":[],"mappings":"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"}

package/option.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MassargHelpFlag = exports.MassargFlag = exports.MassargNumber = exports.MassargOption = exports.ArrayOptionConfig = exports.TypedOptionConfig = exports.OptionConfig = void 0;
+exports.MassargHelpFlag = exports.MassargFlag = exports.MassargNumber = exports.MassargOption = exports.DEFAULT_OPT_SHORT_PREFIX = exports.DEFAULT_OPT_FULL_PREFIX = exports.ArrayOptionConfig = exports.TypedOptionConfig = exports.FlagConfig = exports.OptionConfig = void 0;
 const zod_1 = require("zod");
 const error_1 = require("./error");
 const utils_1 = require("./utils");
@@ -17,7 +17,7 @@ const OptionConfig = (type) => zod_1.z.object({
      * Parse the value of the option. You can return any type here, or throw an error if the value
      * is invalid.
      */
-    parse: zod_1.z.function().args(zod_1.z.string()).returns(type).optional(),
+    parse: zod_1.z.function().args(zod_1.z.string(), zod_1.z.any()).returns(type).optional(),
     /**
      * Whether the option is an array.
      *
@@ -43,6 +43,32 @@ const OptionConfig = (type) => zod_1.z.object({
     outputName: zod_1.z.string().optional(),
 });
 exports.OptionConfig = OptionConfig;
+/**
+ * Configuration for a flag (boolean argument) that can be passed to a command.
+ */
+exports.FlagConfig = (0, exports.OptionConfig)(zod_1.z.any())
+    .omit({ parse: true, isDefault: true })
+    .merge(zod_1.z.object({
+    /** Whether the flag can be negated, e.g. `--no-verbose` */
+    negatable: zod_1.z.boolean().optional(),
+    /**
+     * Negation name of the option, which can be used with the full option notation.
+     *
+     * Defaults to `no-{name}` of your option's name, e.g. `verbose` becomes `--no-verbose`.
+     *
+     * To use this, you must set `negatable: true` in the option's configuration.
+     */
+    negationName: zod_1.z.string().optional(),
+    /**
+     * Negation aliases for the option, which can be used with the shorthand option notation.
+     *
+     * Defaults to uppercase of each of the aliases provided, e.g. `q` becomes `-Q`.
+     *
+     * To use this, you must set `negatable: true` in the option's configuration.
+     */
+    negationAliases: zod_1.z.string().array().optional(),
+}));
+/** {@link OptionConfig} with a specified value type */
 const TypedOptionConfig = (type) => (0, exports.OptionConfig)(type).merge(zod_1.z.object({
     type: zod_1.z.enum(['number']).optional(),
 }));
@@ -57,11 +83,10 @@ zod_1.z.object({
     defaultValue: zod_1.z.array(type).optional(),
 }));
 exports.ArrayOptionConfig = ArrayOptionConfig;
-// TODO turn to options
-const OPT_FULL_PREFIX = '--';
-const OPT_SHORT_PREFIX = '-';
-const NEGATE_FULL_PREFIX = 'no-';
-const NEGATE_SHORT_PREFIX = '^';
+/** The default prefixes for options */
+exports.DEFAULT_OPT_FULL_PREFIX = '--';
+/** The default prefix for option aliases */
+exports.DEFAULT_OPT_SHORT_PREFIX = '-';
 /**
  * An option that can be passed to a command.
  *
@@ -94,8 +119,13 @@ class MassargOption {
         this.parse = options.parse ?? ((x) => x);
         this.isArray = options.array ?? false;
         this.isDefault = options.isDefault ?? false;
+        this.isRequired = options.required ?? false;
         this.outputName = options.outputName;
     }
+    /**
+     * Create a typed option from a configuration. Currently supports `number` options which
+     * are automatically transformed from `string` to `number`.
+     */
     static fromTypedConfig(config) {
         switch (config.type) {
             case 'number':
@@ -103,11 +133,21 @@ class MassargOption {
         }
         return new MassargOption(config);
     }
-    _parseDetails(argv) {
-        // TODO: support --option=value
+    /**
+     * Returns the key which this option outputs to in the final object.
+     *
+     * @default The camelCase version of this option's name.
+     *
+     * Can be overridden with {@link outputName}.
+     */
+    getOutputName() {
+        return this.outputName || (0, utils_1.toCamelCase)(this.name);
+    }
+    /** @internal */
+    parseDetails(argv, options, prefixes) {
         let input = '';
         try {
-            if (!this._match(argv[0])) {
+            if (!this.isMatch(argv[0], prefixes)) {
                 throw new error_1.ParseError({
                     path: [this.name],
                     code: 'invalid_option',
@@ -117,8 +157,8 @@ class MassargOption {
             }
             argv.shift();
             input = argv.shift();
-            const value = this.parse(input);
-            return { key: this.outputName || (0, utils_1.toCamelCase)(this.name), value, argv };
+            const value = this.parse(input, options);
+            return { key: this.getOutputName(), value, argv };
         }
         catch (e) {
             if ((0, error_1.isZodError)(e)) {
@@ -132,54 +172,27 @@ class MassargOption {
             throw e;
         }
     }
+    /** Get the help string for this option */
     helpString() {
         const aliases = this.aliases.length ? `|${this.aliases.join('|-')}` : '';
         return `--${this.name}${aliases} ${this.description}`;
     }
-    _match(arg) {
-        if (!arg)
-            return false;
-        // full prefix
-        if (arg.startsWith(OPT_FULL_PREFIX)) {
-            // negate full prefix
-            if (arg.startsWith(`--${NEGATE_FULL_PREFIX}`)) {
-                return this.name === arg.slice(`--${NEGATE_FULL_PREFIX}`.length);
-            }
-            return this.name === arg.slice(OPT_FULL_PREFIX.length);
-        }
-        // short prefix
-        if (arg.startsWith(OPT_SHORT_PREFIX) || arg.startsWith(NEGATE_SHORT_PREFIX)) {
-            return this.aliases.includes(arg.slice(OPT_SHORT_PREFIX.length));
-        }
-        // negate short prefix
-        if (arg.startsWith(NEGATE_SHORT_PREFIX)) {
-            return this.aliases.includes(arg.slice(NEGATE_SHORT_PREFIX.length));
-        }
-        // no prefix
-        return false;
-    }
-    _isOption(arg) {
-        return (arg.startsWith(OPT_FULL_PREFIX) ||
-            arg.startsWith(OPT_SHORT_PREFIX) ||
-            arg.startsWith(NEGATE_SHORT_PREFIX));
+    /** Returns true if the flag (including any prefixes) matches the name or aliases */
+    isMatch(arg, prefixes) {
+        const qualifiedNames = this.qualifiedNames(prefixes);
+        return (arg === qualifiedNames.name ||
+            arg === qualifiedNames.negationName ||
+            qualifiedNames.aliases.includes(arg) ||
+            qualifiedNames.negationAliases.includes(arg));
     }
-    static getName(arg) {
-        if (arg.startsWith(OPT_FULL_PREFIX)) {
-            // negate full prefix
-            if (arg.startsWith(`--${NEGATE_FULL_PREFIX}`)) {
-                return arg.slice(`--${NEGATE_FULL_PREFIX}`.length);
-            }
-            return arg.slice(OPT_FULL_PREFIX.length);
-        }
-        // short prefix
-        if (arg.startsWith(OPT_SHORT_PREFIX) || arg.startsWith(NEGATE_SHORT_PREFIX)) {
-            return arg.slice(OPT_SHORT_PREFIX.length);
-        }
-        // negate short prefix
-        if (arg.startsWith(NEGATE_SHORT_PREFIX)) {
-            return arg.slice(NEGATE_SHORT_PREFIX.length);
-        }
-        return '<blank>';
+    /** Return the finalized names that will cause this option to match. */
+    qualifiedNames(prefixes) {
+        return {
+            name: prefixes.normalPrefix + this.name,
+            aliases: this.aliases.map((a) => prefixes.aliasPrefix + a),
+            negationName: '',
+            negationAliases: [],
+        };
     }
 }
 exports.MassargOption = MassargOption;
@@ -206,9 +219,9 @@ class MassargNumber extends MassargOption {
             parse: (value) => Number(value),
         });
     }
-    _parseDetails(argv) {
+    parseDetails(argv, options, prefixes) {
         try {
-            const { argv: _argv, value } = super._parseDetails(argv);
+            const { argv: _argv, value } = super.parseDetails(argv, options, prefixes);
             if (isNaN(value)) {
                 throw new error_1.ParseError({
                     path: [this.name],
@@ -234,15 +247,16 @@ class MassargNumber extends MassargOption {
 }
 exports.MassargNumber = MassargNumber;
 /**
- * An option that can be passed to a command.
+ * A boolean option that can be passed to a command.
  *
  * A flag is an option that is either present or not. It can be used to toggle
  * a boolean value, or to indicate that a command should be run in a different
  * mode.
  *
- * A flag can be negated by prefixing it with `no-`. For example, `--no-verbose`,
- * or by prefixing the alias with `^` instead of `-`. This is configurable via the command's
- * configuration.
+ * A flag can be negated by using `negatable: true`. By default, the negated name is the same
+ * as the option name, prefixed by `no-`, and each of the aliases will be uppercased.
+ * For example, `--verbose` and `--no-verbose`, or `-v` and `-V`.
+ * This behavior can be overridden by the `negatedName` and `negatedAliases` options.
  *
  * @example
  * ```ts
@@ -260,11 +274,24 @@ class MassargFlag extends MassargOption {
             ...options,
             parse: () => true,
         });
+        this.negatable = options.negatable ?? false;
+        this.negationName = options.negationName ?? `no-${options.name}`;
+        this.negationAliases = options.negationAliases ?? this.aliases.map((a) => a.toUpperCase());
     }
-    _parseDetails(argv) {
+    parseDetails(argv, _options, prefixes) {
         try {
-            const isNegation = argv[0]?.startsWith(NEGATE_SHORT_PREFIX) || argv[0]?.startsWith(NEGATE_FULL_PREFIX);
-            if (!this._match(argv[0])) {
+            const qualifiedNames = this.qualifiedNames(prefixes);
+            const isNegation = (qualifiedNames.negationName && argv[0] === qualifiedNames.negationName) ||
+                (qualifiedNames.negationAliases.length && qualifiedNames.negationAliases.includes(argv[0]));
+            if (!this.negatable && isNegation) {
+                throw new error_1.ParseError({
+                    path: [this.name],
+                    code: 'invalid_option',
+                    message: `Option ${this.name} cannot be negated`,
+                    received: JSON.stringify(argv[0]),
+                });
+            }
+            if (!this.isMatch(argv[0], prefixes)) {
                 throw new error_1.ParseError({
                     path: [this.name],
                     code: 'invalid_option',
@@ -274,9 +301,9 @@ class MassargFlag extends MassargOption {
             }
             argv.shift();
             if (isNegation) {
-                return { key: this.name, value: false, argv };
+                return { key: this.getOutputName(), value: false, argv };
             }
-            return { key: this.name, value: true, argv };
+            return { key: this.getOutputName(), value: true, argv };
         }
         catch (e) {
             if ((0, error_1.isZodError)(e)) {
@@ -289,8 +316,16 @@ class MassargFlag extends MassargOption {
             throw e;
         }
     }
+    qualifiedNames(prefixes) {
+        return {
+            ...super.qualifiedNames(prefixes),
+            negationName: prefixes.normalPrefix + this.negationName,
+            negationAliases: this.negationAliases.map((a) => prefixes.aliasPrefix + a),
+        };
+    }
 }
 exports.MassargFlag = MassargFlag;
+/** A flag that can be passed to a command to show the help message. */
 class MassargHelpFlag extends MassargFlag {
     constructor(config = {}) {
         super({