Lines Matching refs:key
125 key: undefined
144 'set-placeholder-key': false,
174 const key = typeof opt === 'object' ? opt.key : opt;
175 const assignment = Object.keys(opt).map(function (key) {
181 return arrayFlagKeys[key];
184 flags[assignment][key] = true;
186 flags.arrays[key] = true;
187 flags.keys.push(key);
189 [].concat(opts.boolean || []).filter(Boolean).forEach(function (key) {
190 flags.bools[key] = true;
191 flags.keys.push(key);
193 [].concat(opts.string || []).filter(Boolean).forEach(function (key) {
194 flags.strings[key] = true;
195 flags.keys.push(key);
197 [].concat(opts.number || []).filter(Boolean).forEach(function (key) {
198 flags.numbers[key] = true;
199 flags.keys.push(key);
201 [].concat(opts.count || []).filter(Boolean).forEach(function (key) {
202 flags.counts[key] = true;
203 flags.keys.push(key);
205 [].concat(opts.normalize || []).filter(Boolean).forEach(function (key) {
206 flags.normalize[key] = true;
207 flags.keys.push(key);
210 Object.entries(opts.narg).forEach(([key, value]) => {
212 flags.nargs[key] = value;
213 flags.keys.push(key);
218 Object.entries(opts.coerce).forEach(([key, value]) => {
220 flags.coercions[key] = value;
221 flags.keys.push(key);
227 [].concat(opts.config).filter(Boolean).forEach(function (key) {
228 flags.configs[key] = true;
232 Object.entries(opts.config).forEach(([key, value]) => {
234 flags.configs[key] = value;
239 extendAliases(opts.key, aliases, opts.default, flags.arrays);
240 Object.keys(defaults).forEach(function (key) {
241 (flags.aliases[key] || []).forEach(function (alias) {
242 defaults[alias] = defaults[key];
254 let key;
283 key = m[1];
284 setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false);
290 key = m[1];
291 if (checkAllAliases(key, flags.arrays)) {
292 i = eatArray(i, key, args);
294 else if (checkAllAliases(key, flags.nargs) !== false) {
295 i = eatNargs(i, key, args);
301 !checkAllAliases(key, flags.bools) &&
302 !checkAllAliases(key, flags.counts)) {
303 setArg(key, next);
307 setArg(key, next);
311 setArg(key, defaultValue(key));
326 key = m[1];
328 !checkAllAliases(key, flags.bools) &&
329 !checkAllAliases(key, flags.counts)) {
330 setArg(key, next);
334 setArg(key, defaultValue(key));
345 key = letters[j];
346 if (checkAllAliases(key, flags.arrays)) {
347 i = eatArray(i, key, args, value);
349 else if (checkAllAliases(key, flags.nargs) !== false) {
350 i = eatNargs(i, key, args, value);
353 setArg(key, value);
378 key = arg.slice(-1)[0];
379 if (!broken && key !== '-') {
380 if (checkAllAliases(key, flags.arrays)) {
381 i = eatArray(i, key, args);
383 else if (checkAllAliases(key, flags.nargs) !== false) {
384 i = eatNargs(i, key, args);
390 !checkAllAliases(key, flags.bools) &&
391 !checkAllAliases(key, flags.counts)) {
392 setArg(key, next);
396 setArg(key, next);
400 setArg(key, defaultValue(key));
408 key = arg.slice(1);
409 setArg(key, defaultValue(key));
429 if (configuration['set-placeholder-key'])
431 Object.keys(flags.counts).forEach(function (key) {
432 if (!hasKey(argv, key.split('.')))
433 setArg(key, 0);
437 notFlags.forEach(function (key) {
438 argv[notFlagsArgv].push(key);
441 Object.keys(argv).filter(key => key !== '--' && key.includes('-')).forEach(key => {
442 delete argv[key];
459 function eatNargs(i, key, args, argAfterEqualSign) {
461 let toEat = checkAllAliases(key, flags.nargs);
465 error = Error(__('Argument unexpected for: %s', key));
467 setArg(key, defaultValue(key));
473 error = Error(__('Not enough arguments following: %s', key));
485 error = Error(__('Not enough arguments following: %s', key));
489 setArg(key, argAfterEqualSign);
493 setArg(key, args[ii]);
497 function eatArray(i, key, args, argAfterEqualSign) {
500 const nargsCount = checkAllAliases(key, flags.nargs);
501 if (checkAllAliases(key, flags.bools) && !(/^(true|false)$/.test(next))) {
506 if (defaults[key] !== undefined) {
507 const defVal = defaults[key];
513 argsToSet.push(processValue(key, argAfterEqualSign, true));
523 argsToSet.push(processValue(key, next, inputIsString));
528 error = Error(__('Not enough arguments following: %s', key));
530 setArg(key, argsToSet);
533 function setArg(key, val, shouldStripQuotes = inputIsString) {
534 if (/-/.test(key) && configuration['camel-case-expansion']) {
535 const alias = key.split('.').map(function (prop) {
538 addNewAlias(key, alias);
540 const value = processValue(key, val, shouldStripQuotes);
541 const splitKey = key.split('.');
543 if (flags.aliases[key]) {
544 flags.aliases[key].forEach(function (x) {
555 if (!(flags.aliases[key] || []).includes(keyProperties.join('.'))) {
560 if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) {
561 const keys = [key].concat(flags.aliases[key] || []);
562 keys.forEach(function (key) {
563 Object.defineProperty(argvReturn, key, {
575 function addNewAlias(key, alias) {
576 if (!(flags.aliases[key] && flags.aliases[key].length)) {
577 flags.aliases[key] = [alias];
581 addNewAlias(alias, key);
584 function processValue(key, val, shouldStripQuotes) {
588 if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) {
593 ? val.map(function (v) { return maybeCoerceNumber(key, v); })
594 : maybeCoerceNumber(key, val);
595 … if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === 'boolean')) {
598 if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) {
606 function maybeCoerceNumber(key, value) {
607 if (!configuration['parse-positional-numbers'] && key === '_')
609 …if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !Array.isArray(v…
611 … if (shouldCoerceNumber || (!isUndefined(value) && checkAllAliases(key, flags.numbers))) {
654 Object.keys(config).forEach(function (key) {
655 const value = config[key];
656 const fullKey = prev ? prev + '.' + key : key;
681 const keys = envVar.split('__').map(function (key, i) {
683 key = key.substring(prefix.length);
685 return camelCase(key);
696 Object.keys(argv).forEach(function (key) {
697 if (!applied.has(key)) {
698 coerce = checkAllAliases(key, flags.coercions);
701 const value = maybeCoerceNumber(key, coerce(argv[key]));
702 ([].concat(flags.aliases[key] || [], key)).forEach(ali => {
715 flags.keys.forEach((key) => {
716 if (~key.indexOf('.'))
718 if (typeof argv[key] === 'undefined')
719 argv[key] = undefined;
724 Object.keys(defaults).forEach(function (key) {
725 if (!hasKey(obj, key.split('.'))) {
726 setKey(obj, key.split('.'), defaults[key]);
728 defaulted[key] = true;
729 (aliases[key] || []).forEach(function (x) {
732 setKey(obj, x.split('.'), defaults[key]);
741 keys.slice(0, -1).forEach(function (key) {
742 o = (o[key] || {});
744 const key = keys[keys.length - 1];
748 return key in o;
754 keys.slice(0, -1).forEach(function (key) {
755 key = sanitizeKey(key);
756 if (typeof o === 'object' && o[key] === undefined) {
757 o[key] = {};
759 if (typeof o[key] !== 'object' || Array.isArray(o[key])) {
760 if (Array.isArray(o[key])) {
761 o[key].push({});
764 o[key] = [o[key], {}];
766 o = o[key][o[key].length - 1];
769 o = o[key];
772 const key = sanitizeKey(keys[keys.length - 1]);
776 if (!duplicate && checkAllAliases(key, flags.nargs)) {
778 …if ((!isUndefined(o[key]) && flags.nargs[key] === 1) || (Array.isArray(o[key]) && o[key].length ==…
779 o[key] = undefined;
783 o[key] = increment(o[key]);
785 else if (Array.isArray(o[key])) {
787 …o[key] = configuration['flatten-duplicate-arrays'] ? o[key].concat(value) : (Array.isArray(o[key][…
790 o[key] = value;
793 o[key] = o[key].concat([value]);
796 else if (o[key] === undefined && isTypeArray) {
797 o[key] = isValueArray ? value : [value];
799 else if (duplicate && !(o[key] === undefined ||
800 checkAllAliases(key, flags.counts) ||
801 checkAllAliases(key, flags.bools))) {
802 o[key] = [o[key], value];
805 o[key] = value;
810 Object.keys(obj || {}).forEach(function (key) {
811 if (flags.aliases[key])
813 flags.aliases[key] = [].concat(aliases[key] || []);
814 flags.aliases[key].concat(key).forEach(function (x) {
817 if (c !== key && flags.aliases[key].indexOf(c) === -1) {
818 flags.aliases[key].push(c);
823 flags.aliases[key].concat(key).forEach(function (x) {
826 if (c !== key && flags.aliases[key].indexOf(c) === -1) {
827 flags.aliases[key].push(c);
832 flags.aliases[key].forEach(function (x) {
833 flags.aliases[x] = [key].concat(flags.aliases[key].filter(function (y) {
840 function checkAllAliases(key, flag) {
841 const toCheck = [].concat(flags.aliases[key] || [], key);
843 const setAlias = toCheck.find(key => keys.includes(key));
846 function hasAnyFlag(key) {
850 return Array.isArray(flag) ? flag.includes(key) : flag[key];
900 function defaultValue(key) {
901 if (!checkAllAliases(key, flags.bools) &&
902 !checkAllAliases(key, flags.counts) &&
903 `${key}` in defaults) {
904 return defaults[key];
907 return defaultForType(guessType(key));
919 function guessType(key) {
921 if (checkAllAliases(key, flags.strings))
923 else if (checkAllAliases(key, flags.numbers))
925 else if (checkAllAliases(key, flags.bools))
927 else if (checkAllAliases(key, flags.arrays))
935 Object.keys(flags.counts).find(key => {
936 if (checkAllAliases(key, flags.arrays)) {
937 … error = Error(__('Invalid configuration: %s, opts.count excludes opts.array.', key));
940 else if (checkAllAliases(key, flags.nargs)) {
941 … error = Error(__('Invalid configuration: %s, opts.count excludes opts.narg.', key));
961 Object.keys(aliases).forEach(function (key) {
962 aliasArrays.push([].concat(aliases[key], key));
994 function sanitizeKey(key) {
995 if (key === '__proto__')
997 return key;