@oclif/core 3.0.0-beta.9 → 3.0.1

package/lib/parser/errors.js

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FailedFlagValidationError = exports.ArgInvalidOptionError = exports.FlagInvalidOptionError = exports.NonExistentFlagsError = exports.UnexpectedArgsError = exports.RequiredFlagError = exports.RequiredArgsError = exports.InvalidArgsSpecError = exports.CLIParseError = exports.CLIError = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const list_1 = require("../cli-ux/list");
 const errors_1 = require("../errors");
+const util_1 = require("../util/util");
 const help_1 = require("./help");
-const list_1 = require("../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; } });
 class CLIParseError extends errors_1.CLIError {
+    parse;
     constructor(options) {
         options.message += '\nSee more help with --help';
         super(options.message);
@@ -17,57 +19,62 @@ class CLIParseError extends errors_1.CLIError {
 }
 exports.CLIParseError = CLIParseError;
 class InvalidArgsSpecError extends CLIParseError {
+    args;
     constructor({ args, parse }) {
         let message = 'Invalid argument spec';
-        const namedArgs = Object.values(args).filter(a => a.name);
+        const namedArgs = Object.values(args).filter((a) => a.name);
         if (namedArgs.length > 0) {
-            const list = (0, list_1.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 });
+        super({ message, parse });
         this.args = args;
     }
 }
 exports.InvalidArgsSpecError = InvalidArgsSpecError;
 class RequiredArgsError extends CLIParseError {
-    constructor({ args, parse, flagsWithMultiple }) {
+    args;
+    constructor({ args, flagsWithMultiple, parse, }) {
         let message = `Missing ${args.length} required arg${args.length === 1 ? '' : 's'}`;
-        const namedArgs = args.filter(a => a.name);
+        const namedArgs = args.filter((a) => a.name);
         if (namedArgs.length > 0) {
-            const list = (0, list_1.renderList)(namedArgs.map(a => [a.name, a.description]));
+            const list = (0, list_1.renderList)(namedArgs.map((a) => [a.name, a.description]));
             message += `:\n${list}`;
         }
         if (flagsWithMultiple?.length) {
-            const flags = flagsWithMultiple.map(f => `--${f}`).join(', ');
+            const flags = flagsWithMultiple.map((f) => `--${f}`).join(', ');
             message += `\n\nNote: ${flags} allow${flagsWithMultiple.length === 1 ? 's' : ''} multiple values. Because of this you need to provide all arguments before providing ${flagsWithMultiple.length === 1 ? 'that flag' : 'those flags'}.`;
             message += '\nAlternatively, you can use "--" to signify the end of the flags and the beginning of arguments.';
         }
-        super({ parse, message });
+        super({ message, parse });
         this.args = args;
     }
 }
 exports.RequiredArgsError = RequiredArgsError;
 class RequiredFlagError extends CLIParseError {
+    flag;
     constructor({ flag, parse }) {
         const usage = (0, list_1.renderList)((0, help_1.flagUsages)([flag], { displayRequired: false }));
         const message = `Missing required flag:\n${usage}`;
-        super({ parse, message });
+        super({ message, parse });
         this.flag = flag;
     }
 }
 exports.RequiredFlagError = RequiredFlagError;
 class UnexpectedArgsError extends CLIParseError {
-    constructor({ parse, args }) {
+    args;
+    constructor({ args, parse }) {
         const message = `Unexpected argument${args.length === 1 ? '' : 's'}: ${args.join(', ')}`;
-        super({ parse, message });
+        super({ message, parse });
         this.args = args;
     }
 }
 exports.UnexpectedArgsError = UnexpectedArgsError;
 class NonExistentFlagsError extends CLIParseError {
-    constructor({ parse, flags }) {
+    flags;
+    constructor({ flags, parse }) {
         const message = `Nonexistent flag${flags.length === 1 ? '' : 's'}: ${flags.join(', ')}`;
-        super({ parse, message });
+        super({ message, parse });
         this.flags = flags;
     }
 }
@@ -75,24 +82,24 @@ exports.NonExistentFlagsError = NonExistentFlagsError;
 class FlagInvalidOptionError extends CLIParseError {
     constructor(flag, input) {
         const message = `Expected --${flag.name}=${input} to be one of: ${flag.options.join(', ')}`;
-        super({ parse: {}, message });
+        super({ message, parse: {} });
     }
 }
 exports.FlagInvalidOptionError = FlagInvalidOptionError;
 class ArgInvalidOptionError extends CLIParseError {
     constructor(arg, input) {
         const message = `Expected ${input} to be one of: ${arg.options.join(', ')}`;
-        super({ parse: {}, message });
+        super({ message, parse: {} });
     }
 }
 exports.ArgInvalidOptionError = ArgInvalidOptionError;
 class FailedFlagValidationError extends CLIParseError {
-    constructor({ parse, failed }) {
-        const reasons = failed.map(r => r.reason);
+    constructor({ failed, parse }) {
+        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  ${chalk.dim(deduped.join('\n  '))}`;
-        super({ parse, message });
+        const message = `The following ${errString} occurred:\n  ${chalk_1.default.dim(deduped.join('\n  '))}`;
+        super({ message, parse });
     }
 }
 exports.FailedFlagValidationError = FailedFlagValidationError;

package/lib/parser/help.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.flagUsages = exports.flagUsage = void 0;
-const chalk = require("chalk");
-const util_1 = require("../util");
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const util_1 = require("../util/util");
 function flagUsage(flag, options = {}) {
     const label = [];
     if (flag.helpLabel) {
@@ -18,14 +19,13 @@ function flagUsage(flag, options = {}) {
     let description = flag.summary || flag.description || '';
     if (options.displayRequired && flag.required)
         description = `(required) ${description}`;
-    description = description ? chalk.dim(description) : undefined;
+    description = description ? chalk_1.default.dim(description) : undefined;
     return [` ${label.join(',').trim()}${usage}`, description];
 }
 exports.flagUsage = flagUsage;
 function flagUsages(flags, options = {}) {
     if (flags.length === 0)
         return [];
-    return (0, util_1.sortBy)(flags, f => [f.char ? -1 : 1, f.char, f.name])
-        .map(f => flagUsage(f, options));
+    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.js

@@ -7,11 +7,11 @@ var help_1 = require("./help");
 Object.defineProperty(exports, "flagUsages", { enumerable: true, get: function () { return help_1.flagUsages; } });
 async function parse(argv, options) {
     const input = {
+        '--': options['--'],
+        args: (options.args ?? {}),
         argv,
         context: options.context,
-        '--': options['--'],
         flags: (options.flags ?? {}),
-        args: (options.args ?? {}),
         strict: options.strict !== false,
     };
     const parser = new parse_1.Parser(input);

package/lib/parser/parse.d.ts

@@ -2,18 +2,21 @@ import { OutputArgs, OutputFlags, ParserInput, ParserOutput } from '../interface
 export declare class Parser<T extends ParserInput, TFlags extends OutputFlags<T['flags']>, BFlags extends OutputFlags<T['flags']>, TArgs extends OutputArgs<T['args']>> {
     private readonly input;
     private readonly argv;
-    private readonly raw;
     private readonly booleanFlags;
-    private readonly flagAliases;
     private readonly context;
     private currentFlag?;
+    private readonly flagAliases;
+    private readonly raw;
     constructor(input: T);
-    parse(): Promise<ParserOutput<TFlags, BFlags, TArgs>>;
-    private _flags;
+    private get _argTokens();
     private _args;
-    private _debugOutput;
     private _debugInput;
-    private get _argTokens();
+    private _debugOutput;
+    private _flags;
     private _setNames;
+    private findFlag;
+    private findLongFlag;
+    private findShortFlag;
     private mapAndValidateFlags;
+    parse(): Promise<ParserOutput<TFlags, BFlags, TArgs>>;
 }