Lines Matching refs:key
31 key: undefined
86 const key = typeof opt === 'object' ? opt.key : opt;
88 const assignment = Object.keys(opt).map(function (key) { argument
94 return arrayFlagKeys[key];
98 flags[assignment][key] = true;
100 flags.arrays[key] = true;
101 flags.keys.push(key);
103 [].concat(opts.boolean || []).filter(Boolean).forEach(function (key) { argument
104 flags.bools[key] = true;
105 flags.keys.push(key);
107 [].concat(opts.string || []).filter(Boolean).forEach(function (key) { argument
108 flags.strings[key] = true;
109 flags.keys.push(key);
111 [].concat(opts.number || []).filter(Boolean).forEach(function (key) { argument
112 flags.numbers[key] = true;
113 flags.keys.push(key);
115 [].concat(opts.count || []).filter(Boolean).forEach(function (key) { argument
116 flags.counts[key] = true;
117 flags.keys.push(key);
119 [].concat(opts.normalize || []).filter(Boolean).forEach(function (key) { argument
120 flags.normalize[key] = true;
121 flags.keys.push(key);
124 Object.entries(opts.narg).forEach(([key, value]) => {
126 flags.nargs[key] = value;
127 flags.keys.push(key);
132 Object.entries(opts.coerce).forEach(([key, value]) => {
134 flags.coercions[key] = value;
135 flags.keys.push(key);
142 [].concat(opts.config).filter(Boolean).forEach(function (key) { argument
143 flags.configs[key] = true;
147 Object.entries(opts.config).forEach(([key, value]) => {
149 flags.configs[key] = value;
156 extendAliases(opts.key, aliases, opts.default, flags.arrays);
158 Object.keys(defaults).forEach(function (key) { argument
159 (flags.aliases[key] || []).forEach(function (alias) {
160 defaults[alias] = defaults[key];
175 let key;
213 key = m[1];
214 setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false);
221 key = m[1];
222 if (checkAllAliases(key, flags.arrays)) {
224 i = eatArray(i, key, args);
226 else if (checkAllAliases(key, flags.nargs) !== false) {
229 i = eatNargs(i, key, args);
235 !checkAllAliases(key, flags.bools) &&
236 !checkAllAliases(key, flags.counts)) {
237 setArg(key, next);
241 setArg(key, next);
245 setArg(key, defaultValue(key));
262 key = m[1];
264 !checkAllAliases(key, flags.bools) &&
265 !checkAllAliases(key, flags.counts)) {
266 setArg(key, next);
270 setArg(key, defaultValue(key));
281 key = letters[j];
282 if (checkAllAliases(key, flags.arrays)) {
284 i = eatArray(i, key, args, value);
286 else if (checkAllAliases(key, flags.nargs) !== false) {
288 i = eatNargs(i, key, args, value);
291 setArg(key, value);
317 key = arg.slice(-1)[0];
318 if (!broken && key !== '-') {
319 if (checkAllAliases(key, flags.arrays)) {
321 i = eatArray(i, key, args);
323 else if (checkAllAliases(key, flags.nargs) !== false) {
326 i = eatNargs(i, key, args);
332 !checkAllAliases(key, flags.bools) &&
333 !checkAllAliases(key, flags.counts)) {
334 setArg(key, next);
338 setArg(key, next);
342 setArg(key, defaultValue(key));
351 key = arg.slice(1);
352 setArg(key, defaultValue(key));
381 Object.keys(flags.counts).forEach(function (key) { argument
382 if (!hasKey(argv, key.split('.')))
383 setArg(key, 0);
388 notFlags.forEach(function (key) { argument
389 argv[notFlagsArgv].push(key);
392 Object.keys(argv).filter(key => key !== '--' && key.includes('-')).forEach(key => {
393 delete argv[key];
414 function eatNargs(i, key, args, argAfterEqualSign) { argument
416 let toEat = checkAllAliases(key, flags.nargs);
422 error = Error(__('Argument unexpected for: %s', key));
424 setArg(key, defaultValue(key));
431 error = Error(__('Not enough arguments following: %s', key));
445 error = Error(__('Not enough arguments following: %s', key));
449 setArg(key, argAfterEqualSign);
453 setArg(key, args[ii]);
460 function eatArray(i, key, args, argAfterEqualSign) { argument
464 const nargsCount = checkAllAliases(key, flags.nargs);
465 if (checkAllAliases(key, flags.bools) && !(/^(true|false)$/.test(next))) {
472 if (defaults[key] !== undefined) {
473 const defVal = defaults[key];
480 argsToSet.push(processValue(key, argAfterEqualSign, true));
490 argsToSet.push(processValue(key, next, inputIsString));
498 error = Error(__('Not enough arguments following: %s', key));
500 setArg(key, argsToSet);
503 function setArg(key, val, shouldStripQuotes = inputIsString) { argument
504 if (/-/.test(key) && configuration['camel-case-expansion']) {
505 const alias = key.split('.').map(function (prop) {
508 addNewAlias(key, alias);
510 const value = processValue(key, val, shouldStripQuotes);
511 const splitKey = key.split('.');
514 if (flags.aliases[key]) {
515 flags.aliases[key].forEach(function (x) {
531 if (!(flags.aliases[key] || []).includes(keyProperties.join('.'))) {
537 if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) {
538 const keys = [key].concat(flags.aliases[key] || []);
539 keys.forEach(function (key) { argument
540 Object.defineProperty(argvReturn, key, {
552 function addNewAlias(key, alias) { argument
553 if (!(flags.aliases[key] && flags.aliases[key].length)) {
554 flags.aliases[key] = [alias];
558 addNewAlias(alias, key);
561 function processValue(key, val, shouldStripQuotes) { argument
567 if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) {
572 ? val.map(function (v) { return maybeCoerceNumber(key, v); })
573 : maybeCoerceNumber(key, val);
575 … if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === 'boolean')) {
579 if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) {
587 function maybeCoerceNumber(key, value) { argument
588 if (!configuration['parse-positional-numbers'] && key === '_')
590 …if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !Array.isArray(v…
592 … if (shouldCoerceNumber || (!isUndefined(value) && checkAllAliases(key, flags.numbers))) {
643 Object.keys(config).forEach(function (key) { argument
644 const value = config[key];
645 const fullKey = prev ? prev + '.' + key : key;
678 const keys = envVar.split('__').map(function (key, i) { argument
680 key = key.substring(prefix.length);
682 return camelCase(key);
693 Object.keys(argv).forEach(function (key) { argument
694 … if (!applied.has(key)) { // If we haven't already coerced this option via one of its aliases
695 coerce = checkAllAliases(key, flags.coercions);
698 const value = maybeCoerceNumber(key, coerce(argv[key]));
699 ([].concat(flags.aliases[key] || [], key)).forEach(ali => {
712 flags.keys.forEach((key) => {
714 if (~key.indexOf('.'))
716 if (typeof argv[key] === 'undefined')
717 argv[key] = undefined;
722 Object.keys(defaults).forEach(function (key) { argument
723 if (!hasKey(obj, key.split('.'))) {
724 setKey(obj, key.split('.'), defaults[key]);
726 defaulted[key] = true;
727 (aliases[key] || []).forEach(function (x) {
730 setKey(obj, x.split('.'), defaults[key]);
739 keys.slice(0, -1).forEach(function (key) { argument
740 o = (o[key] || {});
742 const key = keys[keys.length - 1];
746 return key in o;
752 keys.slice(0, -1).forEach(function (key) { argument
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])) {
761 if (Array.isArray(o[key])) {
762 o[key].push({});
765 o[key] = [o[key], {}];
768 o = o[key][o[key].length - 1];
771 o = o[key];
776 const key = sanitizeKey(keys[keys.length - 1]);
781 if (!duplicate && checkAllAliases(key, flags.nargs)) {
783 …if ((!isUndefined(o[key]) && flags.nargs[key] === 1) || (Array.isArray(o[key]) && o[key].length ==…
784 o[key] = undefined;
788 o[key] = increment(o[key]);
790 else if (Array.isArray(o[key])) {
792 …o[key] = configuration['flatten-duplicate-arrays'] ? o[key].concat(value) : (Array.isArray(o[key][…
795 o[key] = value;
798 o[key] = o[key].concat([value]);
801 else if (o[key] === undefined && isTypeArray) {
802 o[key] = isValueArray ? value : [value];
804 else if (duplicate && !(o[key] === undefined ||
805 checkAllAliases(key, flags.counts) ||
806 checkAllAliases(key, flags.bools))) {
807 o[key] = [o[key], value];
810 o[key] = value;
816 Object.keys(obj || {}).forEach(function (key) { argument
820 if (flags.aliases[key])
822 flags.aliases[key] = [].concat(aliases[key] || []);
824 flags.aliases[key].concat(key).forEach(function (x) {
827 if (c !== key && flags.aliases[key].indexOf(c) === -1) {
828 flags.aliases[key].push(c);
834 flags.aliases[key].concat(key).forEach(function (x) {
837 if (c !== key && flags.aliases[key].indexOf(c) === -1) {
838 flags.aliases[key].push(c);
843 flags.aliases[key].forEach(function (x) {
844 flags.aliases[x] = [key].concat(flags.aliases[key].filter(function (y) {
851 function checkAllAliases(key, flag) { argument
852 const toCheck = [].concat(flags.aliases[key] || [], key);
854 const setAlias = toCheck.find(key => keys.includes(key));
857 function hasAnyFlag(key) { argument
861 return Array.isArray(flag) ? flag.includes(key) : flag[key];
923 function defaultValue(key) { argument
924 if (!checkAllAliases(key, flags.bools) &&
925 !checkAllAliases(key, flags.counts) &&
926 `${key}` in defaults) {
927 return defaults[key];
930 return defaultForType(guessType(key));
944 function guessType(key) { argument
946 if (checkAllAliases(key, flags.strings))
948 else if (checkAllAliases(key, flags.numbers))
950 else if (checkAllAliases(key, flags.bools))
952 else if (checkAllAliases(key, flags.arrays))
962 Object.keys(flags.counts).find(key => {
963 if (checkAllAliases(key, flags.arrays)) {
964 … error = Error(__('Invalid configuration: %s, opts.count excludes opts.array.', key));
967 else if (checkAllAliases(key, flags.nargs)) {
968 … error = Error(__('Invalid configuration: %s, opts.count excludes opts.narg.', key));
992 Object.keys(aliases).forEach(function (key) { argument
993 aliasArrays.push([].concat(aliases[key], key));
1034 function sanitizeKey(key) { argument
1035 if (key === '__proto__')
1037 return key;