@oclif/core 2.0.0-beta.3 → 2.0.0-beta.4

package/lib/interfaces/parser.d.ts

@@ -1,62 +1,37 @@
+import { Command } from '../command';
 import { AlphabetLowercase, AlphabetUppercase } from './alphabet';
 import { Config } from './config';
-export type ParseFn<T> = (input: string) => Promise<T>;
-export interface Arg<T = string> {
-    name: string;
-    description?: string;
-    required?: boolean;
-    hidden?: boolean;
-    parse?: ParseFn<T>;
-    default?: T | (() => T);
-    options?: string[];
-    ignoreStdin?: boolean;
-}
-export interface ArgBase<T> {
-    name?: string;
-    description?: string;
-    hidden?: boolean;
-    parse: ParseFn<T>;
-    default?: T | (() => Promise<T>);
-    input?: string;
-    options?: string[];
-    ignoreStdin?: boolean;
-}
-export type RequiredArg<T> = ArgBase<T> & {
-    required: true;
-    value: T;
-};
-export type OptionalArg<T> = ArgBase<T> & {
-    required: false;
-    value?: T;
+export type FlagOutput = {
+    [name: string]: any;
 };
-export type ParserArg<T> = RequiredArg<T> | OptionalArg<T>;
-export interface FlagOutput {
+export type ArgOutput = {
     [name: string]: any;
-}
-export type ArgInput = Arg<any>[];
-export interface CLIParseErrorOptions {
+};
+export type CLIParseErrorOptions = {
     parse: {
         input?: ParserInput;
         output?: ParserOutput;
     };
-}
-export type OutputArgs = {
-    [name: string]: any;
+};
+export type OutputArgs<T extends ParserInput['args']> = {
+    [P in keyof T]: any;
 };
 export type OutputFlags<T extends ParserInput['flags']> = {
     [P in keyof T]: any;
 };
-export type ParserOutput<TFlags extends OutputFlags<any> = any, GFlags extends OutputFlags<any> = any, TArgs extends OutputArgs = any> = {
-    flags: TFlags & GFlags & {
+export type ParserOutput<TFlags extends OutputFlags<any> = any, BFlags extends OutputFlags<any> = any, TArgs extends OutputFlags<any> = any> = {
+    flags: TFlags & BFlags & {
         json: boolean | undefined;
     };
     args: TArgs;
-    argv: string[];
+    argv: unknown[];
     raw: ParsingToken[];
     metadata: Metadata;
+    nonExistentFlags: string[];
 };
 export type ArgToken = {
     type: 'arg';
+    arg: string;
     input: string;
 };
 export type FlagToken = {
@@ -65,9 +40,9 @@ export type FlagToken = {
     input: string;
 };
 export type ParsingToken = ArgToken | FlagToken;
-export interface FlagUsageOptions {
+export type FlagUsageOptions = {
     displayRequired?: boolean;
-}
+};
 export type Metadata = {
     flags: {
         [key: string]: MetadataFlag;
@@ -78,12 +53,15 @@ type MetadataFlag = {
 };
 export type ListItem = [string, string | undefined];
 export type List = ListItem[];
-export type DefaultContext<T, P> = {
-    options: P & OptionFlag<T>;
+export type CustomOptions = Record<string, unknown>;
+export type DefaultContext<T> = {
+    options: T;
     flags: Record<string, string>;
 };
-export type Default<T, P = Record<string, unknown>> = T | ((context: DefaultContext<T, P>) => Promise<T>);
-export type DefaultHelp<T, P = Record<string, unknown>> = T | ((context: DefaultContext<T, P>) => Promise<string | undefined>);
+export type FlagDefault<T, P = CustomOptions> = T | ((context: DefaultContext<OptionFlag<T, P> & P>) => Promise<T>);
+export type FlagDefaultHelp<T, P = CustomOptions> = T | ((context: DefaultContext<OptionFlag<T, P> & P>) => Promise<string | undefined>);
+export type ArgDefault<T, P = CustomOptions> = T | ((context: DefaultContext<Arg<T, P>>) => Promise<T>);
+export type ArgDefaultHelp<T, P = CustomOptions> = T | ((context: DefaultContext<Arg<T, P>>) => Promise<string | undefined>);
 export type FlagRelationship = string | {
     name: string;
     when: (flags: Record<string, unknown>) => Promise<boolean>;
@@ -160,6 +138,31 @@ export type FlagProps = {
      * Emit deprecation warning when a flag alias is provided
      */
     deprecateAliases?: boolean;
+    /**
+     * Delimiter to separate the values for a multiple value flag.
+     * Only respected if multiple is set to true. Default behavior is to
+     * separate on spaces.
+     */
+    delimiter?: ',';
+};
+export type ArgProps = {
+    name: string;
+    /**
+     * A description of flag usage. If summary is provided, the description
+     * is assumed to be a longer description and will be shown in a separate
+     * section within help.
+     */
+    description?: string;
+    /**
+     * If true, the flag will not be shown in the help.
+     */
+    hidden?: boolean;
+    /**
+     * If true, the flag will be required.
+     */
+    required?: boolean;
+    options?: string[];
+    ignoreStdin?: boolean;
 };
 export type BooleanFlagProps = FlagProps & {
     type: 'boolean';
@@ -171,75 +174,82 @@ export type OptionFlagProps = FlagProps & {
     options?: string[];
     multiple?: boolean;
 };
-export type FlagParser<T, I, P = any> = (input: I, context: any, opts: P & OptionFlag<T>) => Promise<T | T[]>;
-export type FlagBase<T, I, P = any> = FlagProps & {
-    parse: FlagParser<T, I, P>;
+export type FlagParser<T, I extends string | boolean, P = CustomOptions> = (input: I, context: Command, opts: P & OptionFlag<T, P>) => Promise<T>;
+export type ArgParser<T, P = CustomOptions> = (input: string, context: Command, opts: P & Arg<T, P>) => Promise<T>;
+export type Arg<T, P = CustomOptions> = ArgProps & {
+    options?: T[];
+    defaultHelp?: ArgDefaultHelp<T>;
+    input: string[];
+    default?: ArgDefault<T | undefined>;
+    parse: ArgParser<T, P>;
+};
+export type ArgDefinition<T, P = CustomOptions> = {
+    (options: P & ({
+        required: true;
+    } | {
+        default: ArgDefault<T>;
+    }) & Partial<Arg<T, P>>): Arg<T, P>;
+    (options?: P & Partial<Arg<T, P>>): Arg<T | undefined, P>;
 };
-export type BooleanFlag<T> = FlagBase<T, boolean> & BooleanFlagProps & {
+export type BooleanFlag<T> = FlagProps & BooleanFlagProps & {
     /**
      * specifying a default of false is the same as not specifying a default
      */
-    default?: Default<boolean>;
+    default?: FlagDefault<boolean>;
+    parse: (input: boolean, context: Command, opts: FlagProps & BooleanFlagProps) => Promise<T>;
 };
-export type CustomOptionFlag<T, P = any, M = false> = FlagBase<T, string, P> & OptionFlagProps & {
-    defaultHelp?: DefaultHelp<T>;
+export type OptionFlagDefaults<T, P = CustomOptions, M = false> = FlagProps & OptionFlagProps & {
+    parse: FlagParser<T, string, P & OptionFlag<T, P>>;
+    defaultHelp?: FlagDefaultHelp<T>;
     input: string[];
-    default?: M extends true ? Default<T[] | undefined, P> : Default<T | undefined, P>;
+    default?: M extends true ? FlagDefault<T[] | undefined, P> : FlagDefault<T | undefined, P>;
 };
-export type OptionFlag<T> = FlagBase<T, string> & OptionFlagProps & {
-    defaultHelp?: DefaultHelp<T>;
+export type OptionFlag<T, P = CustomOptions> = FlagProps & OptionFlagProps & {
+    parse: FlagParser<T, string, P & OptionFlag<T, P>>;
+    defaultHelp?: FlagDefaultHelp<T, P>;
     input: string[];
 } & ({
-    default?: Default<T | undefined>;
+    default?: FlagDefault<T | undefined, P>;
     multiple: false;
 } | {
-    default?: Default<T[] | undefined>;
+    default?: FlagDefault<T[] | undefined, P>;
     multiple: true;
 });
-export type Definition<T, P = Record<string, unknown>> = {
+export type FlagDefinition<T, P = CustomOptions> = {
     (options: P & {
         multiple: true;
     } & ({
         required: true;
     } | {
-        default: Default<T[]>;
-    }) & Partial<OptionFlag<T>>): OptionFlag<T[]>;
+        default: FlagDefault<T[]>;
+    }) & Partial<OptionFlag<T, P>>): OptionFlag<T[]>;
     (options: P & {
         multiple: true;
-    } & Partial<OptionFlag<T>>): OptionFlag<T[] | undefined>;
+    } & Partial<OptionFlag<T>>): OptionFlag<T[] | undefined, P>;
     (options: P & ({
         required: true;
     } | {
-        default: Default<T>;
-    }) & Partial<OptionFlag<T>>): OptionFlag<T>;
-    (options?: P & Partial<OptionFlag<T>>): OptionFlag<T | undefined>;
+        default: FlagDefault<T>;
+    }) & Partial<OptionFlag<T>>): OptionFlag<T, P>;
+    (options?: P & Partial<OptionFlag<T>>): OptionFlag<T | undefined, P>;
 };
-export 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 type Flag<T> = BooleanFlag<T> | OptionFlag<T>;
-export type Input<TFlags extends FlagOutput, GFlags extends FlagOutput> = {
+export type Input<TFlags extends FlagOutput, BFlags extends FlagOutput, AFlags extends ArgOutput> = {
     flags?: FlagInput<TFlags>;
-    globalFlags?: FlagInput<GFlags>;
-    args?: ArgInput;
+    baseFlags?: FlagInput<BFlags>;
+    args?: ArgInput<AFlags>;
     strict?: boolean;
-    context?: any;
+    context?: Command;
     '--'?: boolean;
 };
-export interface ParserInput {
+export type ParserInput = {
     argv: string[];
     flags: FlagInput<any>;
-    args: ParserArg<any>[];
+    args: ArgInput<any>;
     strict: boolean;
-    context: any;
+    context: Command | undefined;
     '--'?: boolean;
-}
+};
 export type CompletionContext = {
     args?: {
         [name: string]: string;
@@ -265,4 +275,9 @@ export type FlagInput<T extends FlagOutput = {
 }> = {
     [P in keyof T]: CompletableFlag<T[P]>;
 };
+export type ArgInput<T extends ArgOutput = {
+    [arg: string]: any;
+}> = {
+    [P in keyof T]: Arg<T[P]>;
+};
 export {};

package/lib/interfaces/plugin.d.ts

@@ -1,4 +1,4 @@
-import { Command } from './command';
+import { Command } from '../command';
 import { PJSON } from './pjson';
 import { Topic } from './topic';
 export interface PluginOptions {

package/lib/main.d.ts

@@ -2,4 +2,57 @@ import * as Interfaces from './interfaces';
 import { Config } from './config';
 export declare const helpAddition: (argv: string[], config: Interfaces.Config) => boolean;
 export declare const versionAddition: (argv: string[], config?: Interfaces.Config) => boolean;
-export declare function run(argv?: string[], options?: Interfaces.LoadOptions): Promise<unknown>;
+export declare function run(argv?: string[], options?: Interfaces.LoadOptions): Promise<void>;
+/**
+ * Load and run oclif CLI
+ *
+ * @param options - options to load the CLI
+ * @returns Promise<void>
+ *
+ * @example For ESM dev.js
+ * ```
+ * #!/usr/bin/env ts-node
+ * // eslint-disable-next-line node/shebang
+ * (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({type: 'esm', development: true, dir: import.meta.url})
+ * })()
+ * ```
+ *
+ * @example For ESM run.js
+ * ```
+ * #!/usr/bin/env node
+ * // eslint-disable-next-line node/shebang
+ * (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({type: 'esm', dir: import.meta.url})
+ * })()
+ * ```
+ *
+ * @example For CJS dev.js
+ * ```
+ * #!/usr/bin/env node
+ * // eslint-disable-next-line node/shebang
+ * (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({type: 'cjs', development: true, dir: __dirname})
+ * })()
+ * ```
+ *
+ * @example For CJS run.js
+ * ```
+ * #!/usr/bin/env node
+ * // eslint-disable-next-line node/shebang
+ * (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({type: 'cjs', dir: import.meta.url})
+ * })()
+ * ```
+ */
+export declare function execute(options: {
+    type: 'cjs' | 'esm';
+    dir: string;
+    args?: string[];
+    loadOptions?: Interfaces.LoadOptions;
+    development?: boolean;
+}): Promise<void>;

package/lib/main.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = exports.versionAddition = exports.helpAddition = void 0;
+exports.execute = exports.run = exports.versionAddition = exports.helpAddition = void 0;
 const url_1 = require("url");
 const util_1 = require("util");
 const url_2 = require("url");
 const config_1 = require("./config");
 const help_1 = require("./help");
+const settings_1 = require("./settings");
+const _1 = require(".");
+const path_1 = require("path");
 const log = (message = '', ...args) => {
-    // tslint:disable-next-line strict-type-predicates
     message = typeof message === 'string' ? message : (0, util_1.inspect)(message);
     process.stdout.write((0, util_1.format)(message, ...args) + '\n');
 };
@@ -32,14 +34,13 @@ const versionAddition = (argv, config) => {
     return false;
 };
 exports.versionAddition = versionAddition;
-// eslint-disable-next-line default-param-last
-async function run(argv = process.argv.slice(2), options) {
+async function run(argv, options) {
+    argv = argv ?? process.argv.slice(2);
     // Handle the case when a file URL string or URL is passed in such as 'import.meta.url'; covert to file path.
     if (options && ((typeof options === 'string' && options.startsWith('file://')) || options instanceof url_2.URL)) {
         options = (0, url_1.fileURLToPath)(options);
     }
-    // return Main.run(argv, options)
-    const config = await config_1.Config.load(options || (module.parent && module.parent.parent && module.parent.parent.filename) || __dirname);
+    const config = await config_1.Config.load(options ?? require.main?.filename ?? __dirname);
     let [id, ...argvSlice] = (0, help_1.normalizeArgv)(config, argv);
     // run init hook
     await config.runHook('init', { id, argv: argvSlice });
@@ -74,3 +75,66 @@ async function run(argv = process.argv.slice(2), options) {
     await config.runCommand(id, argvSlice, cmd);
 }
 exports.run = run;
+function getTsConfigPath(dir, type) {
+    return type === 'cjs' ? (0, path_1.join)(dir, '..', 'tsconfig.json') : (0, path_1.join)((0, path_1.dirname)((0, url_1.fileURLToPath)(dir)), '..', 'tsconfig.json');
+}
+/**
+ * Load and run oclif CLI
+ *
+ * @param options - options to load the CLI
+ * @returns Promise<void>
+ *
+ * @example For ESM dev.js
+ * ```
+ * #!/usr/bin/env ts-node
+ * // eslint-disable-next-line node/shebang
+ * (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({type: 'esm', development: true, dir: import.meta.url})
+ * })()
+ * ```
+ *
+ * @example For ESM run.js
+ * ```
+ * #!/usr/bin/env node
+ * // eslint-disable-next-line node/shebang
+ * (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({type: 'esm', dir: import.meta.url})
+ * })()
+ * ```
+ *
+ * @example For CJS dev.js
+ * ```
+ * #!/usr/bin/env node
+ * // eslint-disable-next-line node/shebang
+ * (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({type: 'cjs', development: true, dir: __dirname})
+ * })()
+ * ```
+ *
+ * @example For CJS run.js
+ * ```
+ * #!/usr/bin/env node
+ * // eslint-disable-next-line node/shebang
+ * (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({type: 'cjs', dir: import.meta.url})
+ * })()
+ * ```
+ */
+async function execute(options) {
+    if (options.development) {
+        // In dev mode -> use ts-node and dev plugins
+        process.env.NODE_ENV = 'development';
+        require('ts-node').register({
+            project: getTsConfigPath(options.dir, options.type),
+        });
+        settings_1.settings.debug = true;
+    }
+    await run(options.args ?? process.argv.slice(2), options.loadOptions ?? options.dir)
+        .then(async () => (0, _1.flush)())
+        .catch(_1.Errors.handle);
+}
+exports.execute = execute;

package/lib/parser/errors.d.ts

@@ -1,5 +1,6 @@
 import { CLIError } from '../errors';
-import { ParserArg, CLIParseErrorOptions, OptionFlag, Flag } from '../interfaces';
+import { OptionFlag, Flag } from '../interfaces';
+import { Arg, ArgInput, CLIParseErrorOptions } from '../interfaces/parser';
 export { CLIError } from '../errors';
 export type Validation = {
     name: string;
@@ -14,15 +15,15 @@ export declare class CLIParseError extends CLIError {
     });
 }
 export declare class InvalidArgsSpecError extends CLIParseError {
-    args: ParserArg<any>[];
+    args: ArgInput;
     constructor({ args, parse }: CLIParseErrorOptions & {
-        args: ParserArg<any>[];
+        args: ArgInput;
     });
 }
 export declare class RequiredArgsError extends CLIParseError {
-    args: ParserArg<any>[];
+    args: Arg<any>[];
     constructor({ args, parse }: CLIParseErrorOptions & {
-        args: ParserArg<any>[];
+        args: Arg<any>[];
     });
 }
 export declare class RequiredFlagError extends CLIParseError {
@@ -32,16 +33,22 @@ export declare class RequiredFlagError extends CLIParseError {
     });
 }
 export declare class UnexpectedArgsError extends CLIParseError {
-    args: string[];
+    args: unknown[];
     constructor({ parse, args }: CLIParseErrorOptions & {
-        args: string[];
+        args: unknown[];
+    });
+}
+export declare class NonExistentFlagsError extends CLIParseError {
+    flags: string[];
+    constructor({ parse, flags }: CLIParseErrorOptions & {
+        flags: string[];
     });
 }
 export declare class FlagInvalidOptionError extends CLIParseError {
     constructor(flag: OptionFlag<any>, input: string);
 }
 export declare class ArgInvalidOptionError extends CLIParseError {
-    constructor(arg: ParserArg<any>, input: string);
+    constructor(arg: Arg<any>, input: string);
 }
 export declare class FailedFlagValidationError extends CLIParseError {
     constructor({ parse, failed }: CLIParseErrorOptions & {

package/lib/parser/errors.js

@@ -1,18 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FailedFlagValidationError = exports.ArgInvalidOptionError = exports.FlagInvalidOptionError = exports.UnexpectedArgsError = exports.RequiredFlagError = exports.RequiredArgsError = exports.InvalidArgsSpecError = exports.CLIParseError = exports.CLIError = void 0;
+exports.FailedFlagValidationError = exports.ArgInvalidOptionError = exports.FlagInvalidOptionError = exports.NonExistentFlagsError = exports.UnexpectedArgsError = exports.RequiredFlagError = exports.RequiredArgsError = exports.InvalidArgsSpecError = exports.CLIParseError = exports.CLIError = void 0;
 const errors_1 = require("../errors");
-const deps_1 = require("./deps");
+const help_1 = require("./help");
+const list_1 = require("../cli-ux/list");
+const chalk = require("chalk");
 const util_1 = require("../config/util");
 var errors_2 = require("../errors");
 Object.defineProperty(exports, "CLIError", { enumerable: true, get: function () { return errors_2.CLIError; } });
-// eslint-disable-next-line new-cap
-const m = (0, deps_1.default)()
-    // eslint-disable-next-line node/no-missing-require
-    .add('help', () => require('./help'))
-    // eslint-disable-next-line node/no-missing-require
-    .add('list', () => require('./list'))
-    .add('chalk', () => require('chalk'));
 class CLIParseError extends errors_1.CLIError {
     constructor(options) {
         options.message += '\nSee more help with --help';
@@ -24,9 +19,9 @@ exports.CLIParseError = CLIParseError;
 class InvalidArgsSpecError extends CLIParseError {
     constructor({ args, parse }) {
         let message = 'Invalid argument spec';
-        const namedArgs = args.filter(a => a.name);
+        const namedArgs = Object.values(args).filter(a => a.name);
         if (namedArgs.length > 0) {
-            const list = m.list.renderList(namedArgs.map(a => [`${a.name} (${a.required ? 'required' : 'optional'})`, a.description]));
+            const list = (0, list_1.renderList)(namedArgs.map(a => [`${a.name} (${a.required ? 'required' : 'optional'})`, a.description]));
             message += `:\n${list}`;
         }
         super({ parse, message });
@@ -39,7 +34,7 @@ class RequiredArgsError extends CLIParseError {
         let message = `Missing ${args.length} required arg${args.length === 1 ? '' : 's'}`;
         const namedArgs = args.filter(a => a.name);
         if (namedArgs.length > 0) {
-            const list = m.list.renderList(namedArgs.map(a => [a.name, a.description]));
+            const list = (0, list_1.renderList)(namedArgs.map(a => [a.name, a.description]));
             message += `:\n${list}`;
         }
         super({ parse, message });
@@ -49,7 +44,7 @@ class RequiredArgsError extends CLIParseError {
 exports.RequiredArgsError = RequiredArgsError;
 class RequiredFlagError extends CLIParseError {
     constructor({ flag, parse }) {
-        const usage = m.list.renderList(m.help.flagUsages([flag], { displayRequired: false }));
+        const usage = (0, list_1.renderList)((0, help_1.flagUsages)([flag], { displayRequired: false }));
         const message = `Missing required flag:\n${usage}`;
         super({ parse, message });
         this.flag = flag;
@@ -64,6 +59,14 @@ class UnexpectedArgsError extends CLIParseError {
     }
 }
 exports.UnexpectedArgsError = UnexpectedArgsError;
+class NonExistentFlagsError extends CLIParseError {
+    constructor({ parse, flags }) {
+        const message = `Nonexistent flag${flags.length === 1 ? '' : 's'}: ${flags.join(', ')}`;
+        super({ parse, message });
+        this.flags = flags;
+    }
+}
+exports.NonExistentFlagsError = NonExistentFlagsError;
 class FlagInvalidOptionError extends CLIParseError {
     constructor(flag, input) {
         const message = `Expected --${flag.name}=${input} to be one of: ${flag.options.join(', ')}`;
@@ -83,7 +86,7 @@ class FailedFlagValidationError extends CLIParseError {
         const reasons = failed.map(r => r.reason);
         const deduped = (0, util_1.uniq)(reasons);
         const errString = deduped.length === 1 ? 'error' : 'errors';
-        const message = `The following ${errString} occurred:\n  ${m.chalk.dim(deduped.join('\n  '))}`;
+        const message = `The following ${errString} occurred:\n  ${chalk.dim(deduped.join('\n  '))}`;
         super({ parse, message });
     }
 }

package/lib/parser/help.d.ts

@@ -1,3 +1,3 @@
-import { FlagUsageOptions, Flag } from '../interfaces';
+import { Flag, FlagUsageOptions } from '../interfaces/parser';
 export declare function flagUsage(flag: Flag<any>, options?: FlagUsageOptions): [string, string | undefined];
 export declare function flagUsages(flags: Flag<any>[], options?: FlagUsageOptions): [string, string | undefined][];

package/lib/parser/help.js

@@ -1,12 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.flagUsages = exports.flagUsage = void 0;
-const deps_1 = require("./deps");
-// eslint-disable-next-line new-cap
-const m = (0, deps_1.default)()
-    .add('chalk', () => require('chalk'))
-    // eslint-disable-next-line node/no-missing-require
-    .add('util', () => require('./util'));
+const chalk = require("chalk");
+const util_1 = require("../util");
 function flagUsage(flag, options = {}) {
     const label = [];
     if (flag.helpLabel) {
@@ -22,15 +18,14 @@ function flagUsage(flag, options = {}) {
     let description = flag.summary || flag.description || '';
     if (options.displayRequired && flag.required)
         description = `(required) ${description}`;
-    description = description ? m.chalk.dim(description) : undefined;
+    description = description ? chalk.dim(description) : undefined;
     return [` ${label.join(',').trim()}${usage}`, description];
 }
 exports.flagUsage = flagUsage;
 function flagUsages(flags, options = {}) {
     if (flags.length === 0)
         return [];
-    const { sortBy } = m.util;
-    return sortBy(flags, f => [f.char ? -1 : 1, f.char, f.name])
+    return (0, util_1.sortBy)(flags, f => [f.char ? -1 : 1, f.char, f.name])
         .map(f => flagUsage(f, options));
 }
 exports.flagUsages = flagUsages;

package/lib/parser/index.d.ts

@@ -1,10 +1,3 @@
-import * as args from './args';
-import * as flags from './flags';
-import { Input, ParserOutput, OutputFlags, FlagOutput } from '../interfaces';
-export { args };
-export { flags };
+import { Input, OutputArgs, OutputFlags, ParserOutput } from '../interfaces/parser';
 export { flagUsages } from './help';
-export declare function parse<TFlags extends OutputFlags<any>, GFlags extends FlagOutput, TArgs extends {
-    [name: string]: string;
-}>(argv: string[], options: Input<TFlags, GFlags>): Promise<ParserOutput<TFlags, GFlags, TArgs>>;
-export { boolean, integer, url, directory, file, string, build, option, custom } from './flags';
+export declare function parse<TFlags extends OutputFlags<any>, BFlags extends OutputFlags<any>, TArgs extends OutputArgs<any>>(argv: string[], options: Input<TFlags, BFlags, TArgs>): Promise<ParserOutput<TFlags, BFlags, TArgs>>;

package/lib/parser/index.js

@@ -1,43 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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");
-const flags = require("./flags");
-exports.flags = flags;
+exports.parse = exports.flagUsages = void 0;
 const parse_1 = require("./parse");
+const validate_1 = require("./validate");
 var help_1 = require("./help");
 Object.defineProperty(exports, "flagUsages", { enumerable: true, get: function () { return help_1.flagUsages; } });
-// eslint-disable-next-line new-cap
-const m = (0, deps_1.default)()
-    // eslint-disable-next-line node/no-missing-require
-    .add('validate', () => require('./validate').validate);
 async function parse(argv, options) {
     const input = {
         argv,
         context: options.context,
-        args: (options.args || []).map((a) => args.newArg(a)),
         '--': options['--'],
-        flags: {
-            color: flags.defaultFlags.color,
-            ...options.flags,
-        },
+        flags: (options.flags ?? {}),
+        args: (options.args ?? {}),
         strict: options.strict !== false,
     };
     const parser = new parse_1.Parser(input);
     const output = await parser.parse();
-    await m.validate({ input, output });
+    await (0, validate_1.validate)({ input, output });
     return output;
 }
 exports.parse = parse;
-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; } });