@oclif/core 1.14.0 → 1.15.0

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [1.15.0](https://github.com/oclif/core/compare/v1.14.2...v1.15.0) (2022-08-23)
+
+
+### Features
+
+* add InferredFlags type ([#473](https://github.com/oclif/core/issues/473)) ([ee5ce65](https://github.com/oclif/core/commit/ee5ce651899c0ef586d425567ef3b78468dca627))
+
+### [1.14.2](https://github.com/oclif/core/compare/v1.14.1...v1.14.2) (2022-08-18)
+
+
+### Bug Fixes
+
+* add overloads to enum flag ([799455b](https://github.com/oclif/core/commit/799455bbb526b221c806bf8feff6b625dcf50a56))
+
+### [1.14.1](https://github.com/oclif/core/compare/v1.14.0...v1.14.1) (2022-08-16)
+
+
+### Bug Fixes
+
+* parser doesn't validate against options parameter if the value is provided through a env var ([#474](https://github.com/oclif/core/issues/474)) ([fe6dfea](https://github.com/oclif/core/commit/fe6dfea0bcc5cae69c91962430996670decf7887))
+
 ## [1.14.0](https://github.com/oclif/core/compare/v1.13.11...v1.14.0) (2022-08-16)
 
 

package/lib/flags.d.ts

@@ -1,15 +1,21 @@
-import { OptionFlag, Definition, BooleanFlag, EnumFlagOptions } from './interfaces';
-export declare function build<T>(defaults: {
-    parse: OptionFlag<T>['parse'];
-} & Partial<OptionFlag<T>>): Definition<T>;
-export declare function build(defaults: Partial<OptionFlag<string>>): Definition<string>;
-export declare function option<T>(options: {
-    parse: OptionFlag<T>['parse'];
-} & Partial<OptionFlag<T>>): OptionFlag<T | undefined>;
-declare const _enum: <T = string>(opts: EnumFlagOptions<T>) => OptionFlag<T>;
+import { OptionFlag, BooleanFlag, EnumFlagOptions, Default } from './interfaces';
+export { boolean, integer, url, directory, file, string, build, option, custom } from './parser';
+export declare function _enum<T = string>(opts: EnumFlagOptions<T, true> & {
+    multiple: true;
+} & ({
+    required: true;
+} | {
+    default: Default<T[]>;
+})): OptionFlag<T[]>;
+export declare function _enum<T = string>(opts: EnumFlagOptions<T, true> & {
+    multiple: true;
+}): OptionFlag<T[] | undefined>;
+export declare function _enum<T = string>(opts: EnumFlagOptions<T> & ({
+    required: true;
+} | {
+    default: Default<T>;
+})): OptionFlag<T>;
+export declare function _enum<T = string>(opts: EnumFlagOptions<T>): OptionFlag<T | undefined>;
 export { _enum as enum };
-declare const stringFlag: Definition<string>;
-export { stringFlag as string };
-export { boolean, integer, url, directory, file } from './parser';
 export declare const version: (opts?: Partial<BooleanFlag<boolean>>) => BooleanFlag<void>;
 export declare const help: (opts?: Partial<BooleanFlag<boolean>>) => BooleanFlag<void>;

package/lib/flags.js

@@ -1,17 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.help = exports.version = exports.file = exports.directory = exports.url = exports.integer = exports.boolean = exports.string = exports.enum = exports.option = exports.build = void 0;
-const Parser = require("./parser");
-function build(defaults) {
-    return Parser.flags.build(defaults);
-}
-exports.build = build;
-function option(options) {
-    return build(options)();
-}
-exports.option = option;
-const _enum = (opts) => {
-    return build({
+exports.help = exports.version = exports.enum = exports._enum = exports.custom = exports.option = exports.build = exports.string = exports.file = exports.directory = exports.url = exports.integer = exports.boolean = void 0;
+const parser_1 = require("./parser");
+var parser_2 = require("./parser");
+Object.defineProperty(exports, "boolean", { enumerable: true, get: function () { return parser_2.boolean; } });
+Object.defineProperty(exports, "integer", { enumerable: true, get: function () { return parser_2.integer; } });
+Object.defineProperty(exports, "url", { enumerable: true, get: function () { return parser_2.url; } });
+Object.defineProperty(exports, "directory", { enumerable: true, get: function () { return parser_2.directory; } });
+Object.defineProperty(exports, "file", { enumerable: true, get: function () { return parser_2.file; } });
+Object.defineProperty(exports, "string", { enumerable: true, get: function () { return parser_2.string; } });
+Object.defineProperty(exports, "build", { enumerable: true, get: function () { return parser_2.build; } });
+Object.defineProperty(exports, "option", { enumerable: true, get: function () { return parser_2.option; } });
+Object.defineProperty(exports, "custom", { enumerable: true, get: function () { return parser_2.custom; } });
+function _enum(opts) {
+    return (0, parser_1.custom)({
         async parse(input) {
             if (!opts.options.includes(input))
                 throw new Error(`Expected --${this.name}=${input} to be one of: ${opts.options.join(', ')}`);
@@ -20,18 +22,11 @@ const _enum = (opts) => {
         helpValue: `(${opts.options.join('|')})`,
         ...opts,
     })();
-};
+}
+exports._enum = _enum;
 exports.enum = _enum;
-const stringFlag = build({});
-exports.string = stringFlag;
-var parser_1 = require("./parser");
-Object.defineProperty(exports, "boolean", { enumerable: true, get: function () { return parser_1.boolean; } });
-Object.defineProperty(exports, "integer", { enumerable: true, get: function () { return parser_1.integer; } });
-Object.defineProperty(exports, "url", { enumerable: true, get: function () { return parser_1.url; } });
-Object.defineProperty(exports, "directory", { enumerable: true, get: function () { return parser_1.directory; } });
-Object.defineProperty(exports, "file", { enumerable: true, get: function () { return parser_1.file; } });
 const version = (opts = {}) => {
-    return Parser.flags.boolean({
+    return (0, parser_1.boolean)({
         description: 'Show CLI version.',
         ...opts,
         parse: async (_, cmd) => {
@@ -42,7 +37,7 @@ const version = (opts = {}) => {
 };
 exports.version = version;
 const help = (opts = {}) => {
-    return Parser.flags.boolean({
+    return (0, parser_1.boolean)({
         description: 'Show CLI help.',
         ...opts,
         parse: async (_, cmd) => {

package/lib/interfaces/flags.d.ts

@@ -0,0 +1,34 @@
+import { FlagInput } from './parser';
+/**
+ * Infer the flags that are returned by Command.parse. This is useful for when you want to assign the flags as a class property.
+ *
+ * @example
+ * export type StatusFlags = Interfaces.InferredFlags<typeof Status.flags & typeof Status.globalFlags>
+ *
+ * export abstract class BaseCommand extends Command {
+ *   static enableJsonFlag = true
+ *
+ *   static globalFlags = {
+ *     config: Flags.string({
+ *       description: 'specify config file',
+ *     }),
+ *   }
+ * }
+ *
+ * export default class Status extends BaseCommand {
+ *   static flags = {
+ *     force: Flags.boolean({char: 'f', description: 'a flag'}),
+ *   }
+ *
+ *   public flags!: StatusFlags
+ *
+ *   public async run(): Promise<StatusFlags> {
+ *     const result = await this.parse(Status)
+ *     this.flags = result.flags
+ *     return result.flags
+ *   }
+ * }
+ */
+export declare type InferredFlags<T> = T extends FlagInput<infer F> ? F & {
+    json: boolean | undefined;
+} : unknown;

package/lib/interfaces/flags.js

@@ -1 +1,2 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/interfaces/index.d.ts

@@ -11,3 +11,4 @@ export { PJSON } from './pjson';
 export { Plugin, PluginOptions, Options } from './plugin';
 export { Topic } from './topic';
 export { TSConfig } from './ts-config';
+export { InferredFlags } from './flags';

package/lib/interfaces/parser.d.ts

@@ -78,14 +78,12 @@ declare type MetadataFlag = {
 };
 export declare type ListItem = [string, string | undefined];
 export declare type List = ListItem[];
-export declare type DefaultContext<T> = {
-    options: OptionFlag<T>;
-    flags: {
-        [k: string]: string;
-    };
+export declare type DefaultContext<T, P> = {
+    options: P & OptionFlag<T>;
+    flags: Record<string, string>;
 };
-export declare type Default<T> = T | ((context: DefaultContext<T>) => Promise<T>);
-export declare type DefaultHelp<T> = T | ((context: DefaultContext<T>) => Promise<string | undefined>);
+export declare type Default<T, P = Record<string, unknown>> = T | ((context: DefaultContext<T, P>) => Promise<T>);
+export declare type DefaultHelp<T, P = Record<string, unknown>> = T | ((context: DefaultContext<T, P>) => Promise<string | undefined>);
 export declare type FlagProps = {
     name: string;
     char?: AlphabetLowercase | AlphabetUppercase;
@@ -109,10 +107,30 @@ export declare type FlagProps = {
      * Shows this flag in a separate list in the help.
      */
     helpGroup?: string;
+    /**
+     * Accept an environment variable as input
+     */
+    env?: string;
+    /**
+     * If true, the flag will not be shown in the help.
+     */
     hidden?: boolean;
+    /**
+     * If true, the flag will be required.
+     */
     required?: boolean;
+    /**
+     * List of flags that this flag depends on.
+     */
     dependsOn?: string[];
+    /**
+     * List of flags that cannot be used with this flag.
+     */
     exclusive?: string[];
+    /**
+     * Exactly one of these flags must be provided.
+     */
+    exactlyOne?: string[];
 };
 export declare type BooleanFlagProps = FlagProps & {
     type: 'boolean';
@@ -122,48 +140,60 @@ export declare type OptionFlagProps = FlagProps & {
     type: 'option';
     helpValue?: string;
     options?: string[];
-    multiple: boolean;
+    multiple?: boolean;
 };
-export declare type FlagBase<T, I> = FlagProps & {
-    exactlyOne?: string[];
-    /**
-     * also accept an environment variable as input
-     */
-    env?: string;
-    parse(input: I, context: any): Promise<T>;
+export declare type FlagParser<T, I, P = any> = (input: I, context: any, opts: P & OptionFlag<T>) => Promise<T>;
+export declare type FlagBase<T, I, P = any> = FlagProps & {
+    parse: FlagParser<T, I, P>;
 };
 export declare type BooleanFlag<T> = FlagBase<T, boolean> & BooleanFlagProps & {
     /**
-     * specifying a default of false is the same not specifying a default
+     * specifying a default of false is the same as not specifying a default
      */
     default?: Default<boolean>;
 };
-export declare type OptionFlag<T> = FlagBase<T, string> & OptionFlagProps & {
-    default?: Default<T | undefined>;
+export declare type CustomOptionFlag<T, P = any, M = false> = FlagBase<T, string, P> & OptionFlagProps & {
     defaultHelp?: DefaultHelp<T>;
     input: string[];
+    default?: M extends true ? Default<T[] | undefined, P> : Default<T | undefined, P>;
 };
-export declare type Definition<T> = {
-    (options: {
+export declare type OptionFlag<T> = FlagBase<T, string> & OptionFlagProps & {
+    defaultHelp?: DefaultHelp<T>;
+    input: string[];
+} & ({
+    default?: Default<T | undefined>;
+    multiple: false;
+} | {
+    default?: Default<T[] | undefined>;
+    multiple: true;
+});
+export declare type Definition<T, P = Record<string, unknown>> = {
+    (options: P & {
         multiple: true;
     } & ({
         required: true;
     } | {
-        default: Default<T>;
+        default: Default<T[]>;
     }) & Partial<OptionFlag<T>>): OptionFlag<T[]>;
-    (options: {
+    (options: P & {
         multiple: true;
-    } & Partial<OptionFlag<T[]>>): OptionFlag<T[] | undefined>;
-    (options: ({
+    } & Partial<OptionFlag<T>>): OptionFlag<T[] | undefined>;
+    (options: P & ({
         required: true;
     } | {
         default: Default<T>;
     }) & Partial<OptionFlag<T>>): OptionFlag<T>;
-    (options?: Partial<OptionFlag<T>>): OptionFlag<T | undefined>;
+    (options?: P & Partial<OptionFlag<T>>): OptionFlag<T | undefined>;
 };
-export declare type EnumFlagOptions<T> = Partial<OptionFlag<T>> & {
+export declare type EnumFlagOptions<T, M = false> = Partial<CustomOptionFlag<T, any, M>> & {
     options: T[];
-};
+} & ({
+    default?: Default<T | undefined>;
+    multiple?: false;
+} | {
+    default?: Default<T[] | undefined>;
+    multiple: true;
+});
 export declare type Flag<T> = BooleanFlag<T> | OptionFlag<T>;
 export declare type Input<TFlags extends FlagOutput, GFlags extends FlagOutput> = {
     flags?: FlagInput<TFlags>;

package/lib/parser/flags.d.ts

@@ -1,96 +1,59 @@
 /// <reference types="node" />
 import { URL } from 'url';
-import { Definition, OptionFlag, BooleanFlag, Default } from '../interfaces';
+import { Definition, OptionFlag, BooleanFlag } from '../interfaces';
+import { FlagParser, CustomOptionFlag } from '../interfaces/parser';
+/**
+ * Create a custom flag.
+ *
+ * @example
+ * type Id = string
+ * type IdOpts = { startsWith: string; length: number };
+ *
+ * export const myFlag = custom<Id, IdOpts>({
+ *   parse: async (input, opts) => {
+ *     if (input.startsWith(opts.startsWith) && input.length === opts.length) {
+ *       return input
+ *     }
+ *
+ *     throw new Error('Invalid id')
+ *   },
+ * })
+ */
+export declare function custom<T, P = Record<string, unknown>>(defaults: {
+    parse: FlagParser<T, string, P>;
+    multiple: true;
+} & Partial<CustomOptionFlag<T, P, true>>): Definition<T, P>;
+export declare function custom<T, P = Record<string, unknown>>(defaults: {
+    parse: FlagParser<T, string, P>;
+} & Partial<CustomOptionFlag<T, P>>): Definition<T, P>;
+export declare function custom<T = string, P = Record<string, unknown>>(defaults: Partial<CustomOptionFlag<T, P>>): Definition<T, P>;
+/**
+ * @deprecated Use Flags.custom instead.
+ */
 export declare function build<T>(defaults: {
     parse: OptionFlag<T>['parse'];
 } & Partial<OptionFlag<T>>): Definition<T>;
 export declare function build(defaults: Partial<OptionFlag<string>>): Definition<string>;
 export declare function boolean<T = boolean>(options?: Partial<BooleanFlag<T>>): BooleanFlag<T>;
-export declare function integer(opts: Partial<OptionFlag<number>> & {
-    min?: number;
-    max?: number;
-} & {
-    multiple: true;
-} & ({
-    required: true;
-} | {
-    default: Default<number>;
-})): OptionFlag<number[]>;
-export declare function integer(opts: Partial<OptionFlag<number>> & {
-    min?: number;
-    max?: number;
-} & {
-    multiple: true;
-}): OptionFlag<number[] | undefined>;
-export declare function integer(opts: Partial<OptionFlag<number>> & {
-    min?: number;
-    max?: number;
-} & ({
-    required: true;
-} | {
-    default: Default<number>;
-})): OptionFlag<number>;
-export declare function integer(opts?: Partial<OptionFlag<number>> & {
-    min?: number;
-    max?: number;
-}): OptionFlag<number | undefined>;
-export declare function directory(opts: Partial<OptionFlag<string>> & {
-    exists?: boolean;
-} & {
-    multiple: true;
-} & ({
-    required: true;
-} | {
-    default: Default<string>;
-})): OptionFlag<string[]>;
-export declare function directory(opts: Partial<OptionFlag<string>> & {
-    exists?: boolean;
-} & {
-    multiple: true;
-}): OptionFlag<string[] | undefined>;
-export declare function directory(opts: {
-    exists?: boolean;
-} & Partial<OptionFlag<string>> & ({
-    required: true;
-} | {
-    default: Default<string>;
-})): OptionFlag<string>;
-export declare function directory(opts?: {
-    exists?: boolean;
-} & Partial<OptionFlag<string>>): OptionFlag<string | undefined>;
-export declare function file(opts: Partial<OptionFlag<string>> & {
-    exists?: boolean;
-} & {
-    multiple: true;
-} & ({
-    required: true;
-} | {
-    default: Default<string>;
-})): OptionFlag<string[]>;
-export declare function file(opts: Partial<OptionFlag<string>> & {
-    exists?: boolean;
-} & {
-    multiple: true;
-}): OptionFlag<string[] | undefined>;
-export declare function file(opts: {
-    exists?: boolean;
-} & Partial<OptionFlag<string>> & ({
-    required: true;
-} | {
-    default: string;
-})): OptionFlag<string>;
-export declare function file(opts?: {
-    exists?: boolean;
-} & Partial<OptionFlag<string>>): OptionFlag<string | undefined>;
+export declare const integer: Definition<number, {
+    min?: number | undefined;
+    max?: number | undefined;
+}>;
+export declare const directory: Definition<string, {
+    exists?: boolean | undefined;
+}>;
+export declare const file: Definition<string, {
+    exists?: boolean | undefined;
+}>;
 /**
  * Initializes a string as a URL. Throws an error
  * if the string is not a valid URL.
  */
-export declare const url: Definition<URL>;
+export declare const url: Definition<URL, Record<string, unknown>>;
 export declare function option<T>(options: {
     parse: OptionFlag<T>['parse'];
-} & Partial<OptionFlag<T>>): OptionFlag<T | undefined>;
-declare const stringFlag: Definition<string>;
+} & Partial<CustomOptionFlag<T>>): OptionFlag<T | undefined>;
+declare const stringFlag: Definition<string, Record<string, unknown>>;
 export { stringFlag as string };
 export declare const defaultFlags: {
     color: BooleanFlag<boolean>;

package/lib/parser/flags.js

@@ -1,13 +1,25 @@
 "use strict";
-// tslint:disable interface-over-type-literal
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultFlags = exports.string = exports.option = exports.url = exports.file = exports.directory = exports.integer = exports.boolean = exports.build = void 0;
+exports.defaultFlags = exports.string = exports.option = exports.url = exports.file = exports.directory = exports.integer = exports.boolean = exports.build = exports.custom = void 0;
 const url_1 = require("url");
 const fs = require("fs");
+function custom(defaults) {
+    return (options = {}) => {
+        return {
+            parse: async (i, _context, _opts) => i,
+            ...defaults,
+            ...options,
+            input: [],
+            multiple: Boolean(options.multiple === undefined ? defaults.multiple : options.multiple),
+            type: 'option',
+        };
+    };
+}
+exports.custom = custom;
 function build(defaults) {
     return (options = {}) => {
         return {
-            parse: async (i, _) => i,
+            parse: async (i, _context) => i,
             ...defaults,
             ...options,
             input: [],
@@ -26,53 +38,37 @@ function boolean(options = {}) {
     };
 }
 exports.boolean = boolean;
-function integer(opts = {}) {
-    return build({
-        ...opts,
-        parse: async (input) => {
-            if (!/^-?\d+$/.test(input))
-                throw new Error(`Expected an integer but received: ${input}`);
-            const num = Number.parseInt(input, 10);
-            if (opts.min !== undefined && num < opts.min)
-                throw new Error(`Expected an integer greater than or equal to ${opts.min} but received: ${input}`);
-            if (opts.max !== undefined && num > opts.max)
-                throw new Error(`Expected an integer less than or equal to ${opts.max} but received: ${input}`);
-            return opts.parse ? opts.parse(input, 1) : num;
-        },
-    })();
-}
-exports.integer = integer;
-function directory(opts = {}) {
-    return build({
-        ...opts,
-        parse: async (input) => {
-            if (opts.exists) {
-                // 2nd "context" arg is required but unused
-                return opts.parse ? opts.parse(await dirExists(input), true) : dirExists(input);
-            }
-            return opts.parse ? opts.parse(input, true) : input;
-        },
-    })();
-}
-exports.directory = directory;
-function file(opts = {}) {
-    return build({
-        ...opts,
-        parse: async (input) => {
-            if (opts.exists) {
-                // 2nd "context" arg is required but unused
-                return opts.parse ? opts.parse(await fileExists(input), true) : fileExists(input);
-            }
-            return opts.parse ? opts.parse(input, true) : input;
-        },
-    })();
-}
-exports.file = file;
+exports.integer = custom({
+    parse: async (input, _, opts) => {
+        if (!/^-?\d+$/.test(input))
+            throw new Error(`Expected an integer but received: ${input}`);
+        const num = Number.parseInt(input, 10);
+        if (opts.min !== undefined && num < opts.min)
+            throw new Error(`Expected an integer greater than or equal to ${opts.min} but received: ${input}`);
+        if (opts.max !== undefined && num > opts.max)
+            throw new Error(`Expected an integer less than or equal to ${opts.max} but received: ${input}`);
+        return num;
+    },
+});
+exports.directory = custom({
+    parse: async (input, _, opts) => {
+        if (opts.exists)
+            return dirExists(input);
+        return input;
+    },
+});
+exports.file = custom({
+    parse: async (input, _, opts) => {
+        if (opts.exists)
+            return fileExists(input);
+        return input;
+    },
+});
 /**
  * Initializes a string as a URL. Throws an error
  * if the string is not a valid URL.
  */
-exports.url = build({
+exports.url = custom({
     parse: async (input) => {
         try {
             return new url_1.URL(input);
@@ -83,10 +79,10 @@ exports.url = build({
     },
 });
 function option(options) {
-    return build(options)();
+    return custom(options)();
 }
 exports.option = option;
-const stringFlag = build({});
+const stringFlag = custom({});
 exports.string = stringFlag;
 exports.defaultFlags = {
     color: boolean({ allowNo: true }),

package/lib/parser/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import * as args from './args';
 import * as flags from './flags';
 import { Input, ParserOutput } from '../interfaces';
@@ -8,5 +7,4 @@ export { flagUsages } from './help';
 export declare function parse<TFlags, GFlags, TArgs extends {
     [name: string]: string;
 }>(argv: string[], options: Input<TFlags, GFlags>): Promise<ParserOutput<TFlags, GFlags, TArgs>>;
-declare const boolean: typeof flags.boolean, integer: typeof flags.integer, url: import("../interfaces").Definition<import("url").URL>, directory: typeof flags.directory, file: typeof flags.file;
-export { boolean, integer, url, directory, file };
+export { boolean, integer, url, directory, file, string, build, option, custom } from './flags';

package/lib/parser/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.file = exports.directory = exports.url = exports.integer = exports.boolean = exports.parse = exports.flagUsages = exports.flags = exports.args = void 0;
+exports.custom = exports.option = exports.build = exports.string = exports.file = exports.directory = exports.url = exports.integer = exports.boolean = exports.parse = exports.flagUsages = exports.flags = exports.args = void 0;
 const args = require("./args");
 exports.args = args;
 const deps_1 = require("./deps");
@@ -31,9 +31,13 @@ async function parse(argv, options) {
     return output;
 }
 exports.parse = parse;
-const { boolean, integer, url, directory, file } = flags;
-exports.boolean = boolean;
-exports.integer = integer;
-exports.url = url;
-exports.directory = directory;
-exports.file = file;
+var flags_1 = require("./flags");
+Object.defineProperty(exports, "boolean", { enumerable: true, get: function () { return flags_1.boolean; } });
+Object.defineProperty(exports, "integer", { enumerable: true, get: function () { return flags_1.integer; } });
+Object.defineProperty(exports, "url", { enumerable: true, get: function () { return flags_1.url; } });
+Object.defineProperty(exports, "directory", { enumerable: true, get: function () { return flags_1.directory; } });
+Object.defineProperty(exports, "file", { enumerable: true, get: function () { return flags_1.file; } });
+Object.defineProperty(exports, "string", { enumerable: true, get: function () { return flags_1.string; } });
+Object.defineProperty(exports, "build", { enumerable: true, get: function () { return flags_1.build; } });
+Object.defineProperty(exports, "option", { enumerable: true, get: function () { return flags_1.option; } });
+Object.defineProperty(exports, "custom", { enumerable: true, get: function () { return flags_1.custom; } });

package/lib/parser/parse.d.ts

@@ -17,6 +17,7 @@ export declare class Parser<T extends ParserInput, TFlags extends OutputFlags<T[
     }>;
     private _args;
     private _flags;
+    private _validateOptions;
     private _argv;
     private _debugOutput;
     private _debugInput;

package/lib/parser/parse.js

@@ -149,15 +149,13 @@ class Parser {
                     flags[token.flag] = true;
                 }
                 // eslint-disable-next-line no-await-in-loop
-                flags[token.flag] = await flag.parse(flags[token.flag], this.context);
+                flags[token.flag] = await flag.parse(flags[token.flag], this.context, flag);
             }
             else {
                 const input = token.input;
-                if (flag.options && !flag.options.includes(input)) {
-                    throw new m.errors.FlagInvalidOptionError(flag, input);
-                }
+                this._validateOptions(flag, input);
                 // eslint-disable-next-line no-await-in-loop
-                const value = flag.parse ? await flag.parse(input, this.context) : input;
+                const value = flag.parse ? await flag.parse(input, this.context, flag) : input;
                 if (flag.multiple) {
                     flags[token.flag] = flags[token.flag] || [];
                     flags[token.flag].push(value);
@@ -173,9 +171,11 @@ class Parser {
                 continue;
             if (flag.type === 'option' && flag.env) {
                 const input = process.env[flag.env];
-                // eslint-disable-next-line no-await-in-loop
-                if (input)
-                    flags[k] = await flag.parse(input, this.context);
+                if (input) {
+                    this._validateOptions(flag, input);
+                    // eslint-disable-next-line no-await-in-loop
+                    flags[k] = await flag.parse(input, this.context, flag);
+                }
             }
             if (!(k in flags) && flag.default !== undefined) {
                 this.metaData.flags[k] = { setFromDefault: true };
@@ -186,6 +186,10 @@ class Parser {
         }
         return flags;
     }
+    _validateOptions(flag, input) {
+        if (flag.options && !flag.options.includes(input))
+            throw new m.errors.FlagInvalidOptionError(flag, input);
+    }
     async _argv() {
         const args = [];
         const tokens = this._argTokens;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oclif/core",
   "description": "base library for oclif CLIs",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/core/issues",
   "dependencies": {
@@ -74,6 +74,7 @@
     "shx": "^0.3.4",
     "sinon": "^11.1.2",
     "ts-node": "^9.1.1",
+    "tsd": "^0.22.0",
     "typescript": "4.5.5"
   },
   "engines": {