projen 0.71.38 → 0.71.39

package/node_modules/yargs/build/lib/usage.js

@@ -1,31 +1,43 @@
-import { assertNotStrictEqual, } from './typings/common-types.js';
 import { objFilter } from './utils/obj-filter.js';
 import { YError } from './yerror.js';
 import setBlocking from './utils/set-blocking.js';
-export function usage(yargs, y18n, shim) {
-    const __ = y18n.__;
+function isBoolean(fail) {
+    return typeof fail === 'boolean';
+}
+export function usage(yargs, shim) {
+    const __ = shim.y18n.__;
     const self = {};
     const fails = [];
     self.failFn = function failFn(f) {
         fails.push(f);
     };
     let failMessage = null;
+    let globalFailMessage = null;
     let showHelpOnFail = true;
     self.showHelpOnFail = function showHelpOnFailFn(arg1 = true, arg2) {
-        function parseFunctionArgs() {
-            return typeof arg1 === 'string' ? [true, arg1] : [arg1, arg2];
+        const [enabled, message] = typeof arg1 === 'string' ? [true, arg1] : [arg1, arg2];
+        if (yargs.getInternalMethods().isGlobalContext()) {
+            globalFailMessage = message;
         }
-        const [enabled, message] = parseFunctionArgs();
         failMessage = message;
         showHelpOnFail = enabled;
         return self;
     };
     let failureOutput = false;
     self.fail = function fail(msg, err) {
-        const logger = yargs._getLoggerInstance();
+        const logger = yargs.getInternalMethods().getLoggerInstance();
         if (fails.length) {
             for (let i = fails.length - 1; i >= 0; --i) {
-                fails[i](msg, err, self);
+                const fail = fails[i];
+                if (isBoolean(fail)) {
+                    if (err)
+                        throw err;
+                    else if (msg)
+                        throw Error(msg);
+                }
+                else {
+                    fail(msg, err, self);
+                }
             }
         }
         else {
@@ -39,17 +51,18 @@ export function usage(yargs, y18n, shim) {
                 }
                 if (msg || err)
                     logger.error(msg || err);
-                if (failMessage) {
+                const globalOrCommandFailMessage = failMessage || globalFailMessage;
+                if (globalOrCommandFailMessage) {
                     if (msg || err)
                         logger.error('');
-                    logger.error(failMessage);
+                    logger.error(globalOrCommandFailMessage);
                 }
             }
             err = err || new YError(msg);
             if (yargs.getExitProcess()) {
                 return yargs.exit(1);
             }
-            else if (yargs._hasParseCallback()) {
+            else if (yargs.getInternalMethods().hasParseCallback()) {
                 return yargs.exit(1, err);
             }
             else {
@@ -120,13 +133,16 @@ export function usage(yargs, y18n, shim) {
         wrapSet = true;
         wrap = cols;
     };
-    function getWrap() {
+    self.getWrap = () => {
+        if (shim.getEnv('YARGS_DISABLE_WRAP')) {
+            return null;
+        }
         if (!wrapSet) {
             wrap = windowWidth();
             wrapSet = true;
         }
         return wrap;
-    }
+    };
     const deferY18nLookupPrefix = '__yargsString__:';
     self.deferY18nLookup = str => deferY18nLookupPrefix + str;
     self.help = function help() {
@@ -152,7 +168,7 @@ export function usage(yargs, y18n, shim) {
                 acc[key] = true;
             return acc;
         }, {}));
-        const theWrap = getWrap();
+        const theWrap = self.getWrap();
         const ui = shim.cliui({
             width: theWrap,
             wrap: !!theWrap,
@@ -160,7 +176,7 @@ export function usage(yargs, y18n, shim) {
         if (!usageDisabled) {
             if (usages.length) {
                 usages.forEach(usage => {
-                    ui.div(`${usage[0].replace(/\$0/g, base$0)}`);
+                    ui.div({ text: `${usage[0].replace(/\$0/g, base$0)}` });
                     if (usage[1]) {
                         ui.div({ text: `${usage[1]}`, padding: [1, 0, 0, 0] });
                     }
@@ -178,17 +194,19 @@ export function usage(yargs, y18n, shim) {
                 ui.div(`${u}`);
             }
         }
-        if (commands.length) {
+        if (commands.length > 1 || (commands.length === 1 && !commands[0][2])) {
             ui.div(__('Commands:'));
-            const context = yargs.getContext();
+            const context = yargs.getInternalMethods().getContext();
             const parentCommands = context.commands.length
                 ? `${context.commands.join(' ')} `
                 : '';
-            if (yargs.getParserConfiguration()['sort-commands'] === true) {
+            if (yargs.getInternalMethods().getParserConfiguration()['sort-commands'] ===
+                true) {
                 commands = commands.sort((a, b) => a[0].localeCompare(b[0]));
             }
+            const prefix = base$0 ? `${base$0} ` : '';
             commands.forEach(command => {
-                const commandString = `${base$0} ${parentCommands}${command[0].replace(/^\$0 ?/, '')}`;
+                const commandString = `${prefix}${parentCommands}${command[0].replace(/^\$0 ?/, '')}`;
                 ui.span({
                     text: commandString,
                     padding: [0, 2, 0, 2],
@@ -235,10 +253,10 @@ export function usage(yargs, y18n, shim) {
             const normalizedKeys = groups[groupName]
                 .filter(filterHiddenOptions)
                 .map(key => {
-                if (~aliasKeys.indexOf(key))
+                if (aliasKeys.includes(key))
                     return key;
                 for (let i = 0, aliasKey; (aliasKey = aliasKeys[i]) !== undefined; i++) {
-                    if (~(options.alias[aliasKey] || []).indexOf(key))
+                    if ((options.alias[aliasKey] || []).includes(key))
                         return aliasKey;
                 }
                 return key;
@@ -255,7 +273,7 @@ export function usage(yargs, y18n, shim) {
                         return sw;
                     else {
                         return ((/^[0-9]$/.test(sw)
-                            ? ~options.boolean.indexOf(key)
+                            ? options.boolean.includes(key)
                                 ? '-'
                                 : '--'
                             : sw.length > 1
@@ -293,19 +311,19 @@ export function usage(yargs, y18n, shim) {
                 const kswitch = switches[key];
                 let desc = descriptions[key] || '';
                 let type = null;
-                if (~desc.lastIndexOf(deferY18nLookupPrefix))
+                if (desc.includes(deferY18nLookupPrefix))
                     desc = __(desc.substring(deferY18nLookupPrefix.length));
-                if (~options.boolean.indexOf(key))
+                if (options.boolean.includes(key))
                     type = `[${__('boolean')}]`;
-                if (~options.count.indexOf(key))
+                if (options.count.includes(key))
                     type = `[${__('count')}]`;
-                if (~options.string.indexOf(key))
+                if (options.string.includes(key))
                     type = `[${__('string')}]`;
-                if (~options.normalize.indexOf(key))
+                if (options.normalize.includes(key))
                     type = `[${__('string')}]`;
-                if (~options.array.indexOf(key))
+                if (options.array.includes(key))
                     type = `[${__('array')}]`;
-                if (~options.number.indexOf(key))
+                if (options.number.includes(key))
                     type = `[${__('number')}]`;
                 const deprecatedExtra = (deprecated) => typeof deprecated === 'string'
                     ? `[${__('deprecated: %s', deprecated)}]`
@@ -328,7 +346,9 @@ export function usage(yargs, y18n, shim) {
                     padding: [0, 2, 0, 2 + getIndentation(kswitch)],
                     width: maxWidth(switches, theWrap) + 4,
                 }, desc);
-                if (extra)
+                const shouldHideOptionExtras = yargs.getInternalMethods().getUsageConfiguration()['hide-types'] ===
+                    true;
+                if (extra && !shouldHideOptionExtras)
                     ui.div({ text: extra, padding: [0, 0, 0, 2], align: 'right' });
                 else
                     ui.div();
@@ -388,17 +408,17 @@ export function usage(yargs, y18n, shim) {
                     self.describe(key, descriptions[alias]);
                 if (alias in demandedOptions)
                     yargs.demandOption(key, demandedOptions[alias]);
-                if (~options.boolean.indexOf(alias))
+                if (options.boolean.includes(alias))
                     yargs.boolean(key);
-                if (~options.count.indexOf(alias))
+                if (options.count.includes(alias))
                     yargs.count(key);
-                if (~options.string.indexOf(alias))
+                if (options.string.includes(alias))
                     yargs.string(key);
-                if (~options.normalize.indexOf(alias))
+                if (options.normalize.includes(alias))
                     yargs.normalize(key);
-                if (~options.array.indexOf(alias))
+                if (options.array.includes(alias))
                     yargs.array(key);
-                if (~options.number.indexOf(alias))
+                if (options.number.includes(alias))
                     yargs.number(key);
             });
         });
@@ -410,6 +430,9 @@ export function usage(yargs, y18n, shim) {
     self.clearCachedHelpMessage = function () {
         cachedHelpMessage = undefined;
     };
+    self.hasCachedHelpMessage = function () {
+        return !!cachedHelpMessage;
+    };
     function addUngroupedKeys(keys, aliases, groups, defaultGroup) {
         let groupedKeys = [];
         let toCheck = null;
@@ -429,7 +452,7 @@ export function usage(yargs, y18n, shim) {
             yargs.parsed.argv[yargs.getOptions().showHiddenOpt]);
     }
     self.showHelp = (level) => {
-        const logger = yargs._getLoggerInstance();
+        const logger = yargs.getInternalMethods().getLoggerInstance();
         if (!level)
             level = 'error';
         const emit = typeof level === 'function' ? level : logger[level];
@@ -488,9 +511,12 @@ export function usage(yargs, y18n, shim) {
     self.version = ver => {
         version = ver;
     };
-    self.showVersion = () => {
-        const logger = yargs._getLoggerInstance();
-        logger.log(version);
+    self.showVersion = level => {
+        const logger = yargs.getInternalMethods().getLoggerInstance();
+        if (!level)
+            level = 'error';
+        const emit = typeof level === 'function' ? level : logger[level];
+        emit(version);
     };
     self.reset = function reset(localLookup) {
         failMessage = null;
@@ -516,19 +542,29 @@ export function usage(yargs, y18n, shim) {
             descriptions,
         });
     };
-    self.unfreeze = function unfreeze() {
+    self.unfreeze = function unfreeze(defaultCommand = false) {
         const frozen = frozens.pop();
-        assertNotStrictEqual(frozen, undefined, shim);
-        ({
-            failMessage,
-            failureOutput,
-            usages,
-            usageDisabled,
-            epilogs,
-            examples,
-            commands,
-            descriptions,
-        } = frozen);
+        if (!frozen)
+            return;
+        if (defaultCommand) {
+            descriptions = { ...frozen.descriptions, ...descriptions };
+            commands = [...frozen.commands, ...commands];
+            usages = [...frozen.usages, ...usages];
+            examples = [...frozen.examples, ...examples];
+            epilogs = [...frozen.epilogs, ...epilogs];
+        }
+        else {
+            ({
+                failMessage,
+                failureOutput,
+                usages,
+                usageDisabled,
+                epilogs,
+                examples,
+                commands,
+                descriptions,
+            } = frozen);
+        }
     };
     return self;
 }

package/node_modules/yargs/build/lib/utils/levenshtein.js

@@ -18,7 +18,15 @@ export function levenshtein(a, b) {
                 matrix[i][j] = matrix[i - 1][j - 1];
             }
             else {
-                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1));
+                if (i > 1 &&
+                    j > 1 &&
+                    b.charAt(i - 2) === a.charAt(j - 1) &&
+                    b.charAt(i - 1) === a.charAt(j - 2)) {
+                    matrix[i][j] = matrix[i - 2][j - 2] + 1;
+                }
+                else {
+                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1));
+                }
             }
         }
     }

package/node_modules/yargs/build/lib/utils/maybe-async-result.js

@@ -0,0 +1,17 @@
+import { isPromise } from './is-promise.js';
+export function maybeAsyncResult(getResult, resultHandler, errorHandler = (err) => {
+    throw err;
+}) {
+    try {
+        const result = isFunction(getResult) ? getResult() : getResult;
+        return isPromise(result)
+            ? result.then((result) => resultHandler(result))
+            : resultHandler(result);
+    }
+    catch (err) {
+        return errorHandler(err);
+    }
+}
+function isFunction(arg) {
+    return typeof arg === 'function';
+}

package/node_modules/yargs/build/lib/validation.js

@@ -3,14 +3,14 @@ import { assertNotStrictEqual, } from './typings/common-types.js';
 import { levenshtein as distance } from './utils/levenshtein.js';
 import { objFilter } from './utils/obj-filter.js';
 const specialKeys = ['$0', '--', '_'];
-export function validation(yargs, usage, y18n, shim) {
-    const __ = y18n.__;
-    const __n = y18n.__n;
+export function validation(yargs, usage, shim) {
+    const __ = shim.y18n.__;
+    const __n = shim.y18n.__n;
     const self = {};
     self.nonOptionCount = function nonOptionCount(argv) {
         const demandedCommands = yargs.getDemandedCommands();
         const positionalCount = argv._.length + (argv['--'] ? argv['--'].length : 0);
-        const _s = positionalCount - yargs.getContext().commands.length;
+        const _s = positionalCount - yargs.getInternalMethods().getContext().commands.length;
         if (demandedCommands._ &&
             (_s < demandedCommands._.min || _s > demandedCommands._.max)) {
             if (_s < demandedCommands._.min) {
@@ -44,8 +44,7 @@ export function validation(yargs, usage, y18n, shim) {
             usage.fail(__n('Not enough non-option arguments: got %s, need at least %s', 'Not enough non-option arguments: got %s, need at least %s', observed, observed + '', required + ''));
         }
     };
-    self.requiredArguments = function requiredArguments(argv) {
-        const demandedOptions = yargs.getDemandedOptions();
+    self.requiredArguments = function requiredArguments(argv, demandedOptions) {
         let missing = null;
         for (const key of Object.keys(demandedOptions)) {
             if (!Object.prototype.hasOwnProperty.call(argv, key) ||
@@ -67,13 +66,17 @@ export function validation(yargs, usage, y18n, shim) {
         }
     };
     self.unknownArguments = function unknownArguments(argv, aliases, positionalMap, isDefaultCommand, checkPositionals = true) {
-        const commandKeys = yargs.getCommandInstance().getCommands();
+        var _a;
+        const commandKeys = yargs
+            .getInternalMethods()
+            .getCommandInstance()
+            .getCommands();
         const unknown = [];
-        const currentContext = yargs.getContext();
+        const currentContext = yargs.getInternalMethods().getContext();
         Object.keys(argv).forEach(key => {
-            if (specialKeys.indexOf(key) === -1 &&
+            if (!specialKeys.includes(key) &&
                 !Object.prototype.hasOwnProperty.call(positionalMap, key) &&
-                !Object.prototype.hasOwnProperty.call(yargs._getParseContext(), key) &&
+                !Object.prototype.hasOwnProperty.call(yargs.getInternalMethods().getParseContext(), key) &&
                 !self.isValidAndSomeAliasIsNotNew(key, aliases)) {
                 unknown.push(key);
             }
@@ -83,22 +86,39 @@ export function validation(yargs, usage, y18n, shim) {
                 commandKeys.length > 0 ||
                 isDefaultCommand)) {
             argv._.slice(currentContext.commands.length).forEach(key => {
-                if (commandKeys.indexOf('' + key) === -1) {
+                if (!commandKeys.includes('' + key)) {
                     unknown.push('' + key);
                 }
             });
         }
-        if (unknown.length > 0) {
-            usage.fail(__n('Unknown argument: %s', 'Unknown arguments: %s', unknown.length, unknown.join(', ')));
+        if (checkPositionals) {
+            const demandedCommands = yargs.getDemandedCommands();
+            const maxNonOptDemanded = ((_a = demandedCommands._) === null || _a === void 0 ? void 0 : _a.max) || 0;
+            const expected = currentContext.commands.length + maxNonOptDemanded;
+            if (expected < argv._.length) {
+                argv._.slice(expected).forEach(key => {
+                    key = String(key);
+                    if (!currentContext.commands.includes(key) &&
+                        !unknown.includes(key)) {
+                        unknown.push(key);
+                    }
+                });
+            }
+        }
+        if (unknown.length) {
+            usage.fail(__n('Unknown argument: %s', 'Unknown arguments: %s', unknown.length, unknown.map(s => (s.trim() ? s : `"${s}"`)).join(', ')));
         }
     };
     self.unknownCommands = function unknownCommands(argv) {
-        const commandKeys = yargs.getCommandInstance().getCommands();
+        const commandKeys = yargs
+            .getInternalMethods()
+            .getCommandInstance()
+            .getCommands();
         const unknown = [];
-        const currentContext = yargs.getContext();
+        const currentContext = yargs.getInternalMethods().getContext();
         if (currentContext.commands.length > 0 || commandKeys.length > 0) {
             argv._.slice(currentContext.commands.length).forEach(key => {
-                if (commandKeys.indexOf('' + key) === -1) {
+                if (!commandKeys.includes('' + key)) {
                     unknown.push('' + key);
                 }
             });
@@ -116,13 +136,7 @@ export function validation(yargs, usage, y18n, shim) {
             return false;
         }
         const newAliases = yargs.parsed.newAliases;
-        for (const a of [key, ...aliases[key]]) {
-            if (!Object.prototype.hasOwnProperty.call(newAliases, a) ||
-                !newAliases[key]) {
-                return true;
-            }
-        }
-        return false;
+        return [key, ...aliases[key]].some(a => !Object.prototype.hasOwnProperty.call(newAliases, a) || !newAliases[key]);
     };
     self.limitedChoices = function limitedChoices(argv) {
         const options = yargs.getOptions();
@@ -149,32 +163,6 @@ export function validation(yargs, usage, y18n, shim) {
         });
         usage.fail(msg);
     };
-    let checks = [];
-    self.check = function check(f, global) {
-        checks.push({
-            func: f,
-            global,
-        });
-    };
-    self.customChecks = function customChecks(argv, aliases) {
-        for (let i = 0, f; (f = checks[i]) !== undefined; i++) {
-            const func = f.func;
-            let result = null;
-            try {
-                result = func(argv, aliases);
-            }
-            catch (err) {
-                usage.fail(err.message ? err.message : err, err);
-                continue;
-            }
-            if (!result) {
-                usage.fail(__('Argument check failed: %s', func.toString()));
-            }
-            else if (typeof result === 'string' || result instanceof Error) {
-                usage.fail(result.toString(), result);
-            }
-        }
-    };
     let implied = {};
     self.implies = function implies(key, value) {
         argsert('<string|object> [array|number|string]', [key, value], arguments.length);
@@ -208,10 +196,10 @@ export function validation(yargs, usage, y18n, shim) {
         }
         else if (val.match(/^--no-.+/)) {
             val = val.match(/^--no-(.+)/)[1];
-            val = !argv[val];
+            val = !Object.prototype.hasOwnProperty.call(argv, val);
         }
         else {
-            val = argv[val];
+            val = Object.prototype.hasOwnProperty.call(argv, val);
         }
         return val;
     }
@@ -269,6 +257,17 @@ export function validation(yargs, usage, y18n, shim) {
                 });
             }
         });
+        if (yargs.getInternalMethods().getParserConfiguration()['strip-dashed']) {
+            Object.keys(conflicting).forEach(key => {
+                conflicting[key].forEach(value => {
+                    if (value &&
+                        argv[shim.Parser.camelCase(key)] !== undefined &&
+                        argv[shim.Parser.camelCase(value)] !== undefined) {
+                        usage.fail(__('Arguments %s and %s are mutually exclusive', key, value));
+                    }
+                });
+            });
+        }
     };
     self.recommendCommands = function recommendCommands(cmd, potentialCommands) {
         const threshold = 3;
@@ -288,21 +287,19 @@ export function validation(yargs, usage, y18n, shim) {
     self.reset = function reset(localLookup) {
         implied = objFilter(implied, k => !localLookup[k]);
         conflicting = objFilter(conflicting, k => !localLookup[k]);
-        checks = checks.filter(c => c.global);
         return self;
     };
     const frozens = [];
     self.freeze = function freeze() {
         frozens.push({
             implied,
-            checks,
             conflicting,
         });
     };
     self.unfreeze = function unfreeze() {
         const frozen = frozens.pop();
         assertNotStrictEqual(frozen, undefined, shim);
-        ({ implied, checks, conflicting } = frozen);
+        ({ implied, conflicting } = frozen);
     };
     return self;
 }