my-idlers/node_modules/arg/index.js
cp6 fd22b0bf58 V2 (Laravel re-make)
V2 (Laravel re-make)
2022-03-06 02:02:12 +11:00

196 lines
4.4 KiB
JavaScript
Vendored

const flagSymbol = Symbol('arg flag');
class ArgError extends Error {
constructor(msg, code) {
super(msg);
this.name = 'ArgError';
this.code = code;
Object.setPrototypeOf(this, ArgError.prototype);
}
}
function arg(
opts,
{
argv = process.argv.slice(2),
permissive = false,
stopAtPositional = false
} = {}
) {
if (!opts) {
throw new ArgError(
'argument specification object is required',
'ARG_CONFIG_NO_SPEC'
);
}
const result = { _: [] };
const aliases = {};
const handlers = {};
for (const key of Object.keys(opts)) {
if (!key) {
throw new ArgError(
'argument key cannot be an empty string',
'ARG_CONFIG_EMPTY_KEY'
);
}
if (key[0] !== '-') {
throw new ArgError(
`argument key must start with '-' but found: '${key}'`,
'ARG_CONFIG_NONOPT_KEY'
);
}
if (key.length === 1) {
throw new ArgError(
`argument key must have a name; singular '-' keys are not allowed: ${key}`,
'ARG_CONFIG_NONAME_KEY'
);
}
if (typeof opts[key] === 'string') {
aliases[key] = opts[key];
continue;
}
let type = opts[key];
let isFlag = false;
if (
Array.isArray(type) &&
type.length === 1 &&
typeof type[0] === 'function'
) {
const [fn] = type;
type = (value, name, prev = []) => {
prev.push(fn(value, name, prev[prev.length - 1]));
return prev;
};
isFlag = fn === Boolean || fn[flagSymbol] === true;
} else if (typeof type === 'function') {
isFlag = type === Boolean || type[flagSymbol] === true;
} else {
throw new ArgError(
`type missing or not a function or valid array type: ${key}`,
'ARG_CONFIG_VAD_TYPE'
);
}
if (key[1] !== '-' && key.length > 2) {
throw new ArgError(
`short argument keys (with a single hyphen) must have only one character: ${key}`,
'ARG_CONFIG_SHORTOPT_TOOLONG'
);
}
handlers[key] = [type, isFlag];
}
for (let i = 0, len = argv.length; i < len; i++) {
const wholeArg = argv[i];
if (stopAtPositional && result._.length > 0) {
result._ = result._.concat(argv.slice(i));
break;
}
if (wholeArg === '--') {
result._ = result._.concat(argv.slice(i + 1));
break;
}
if (wholeArg.length > 1 && wholeArg[0] === '-') {
/* eslint-disable operator-linebreak */
const separatedArguments =
wholeArg[1] === '-' || wholeArg.length === 2
? [wholeArg]
: wholeArg
.slice(1)
.split('')
.map((a) => `-${a}`);
/* eslint-enable operator-linebreak */
for (let j = 0; j < separatedArguments.length; j++) {
const arg = separatedArguments[j];
const [originalArgName, argStr] =
arg[1] === '-' ? arg.split(/=(.*)/, 2) : [arg, undefined];
let argName = originalArgName;
while (argName in aliases) {
argName = aliases[argName];
}
if (!(argName in handlers)) {
if (permissive) {
result._.push(arg);
continue;
} else {
throw new ArgError(
`unknown or unexpected option: ${originalArgName}`,
'ARG_UNKNOWN_OPTION'
);
}
}
const [type, isFlag] = handlers[argName];
if (!isFlag && j + 1 < separatedArguments.length) {
throw new ArgError(
`option requires argument (but was followed by another short argument): ${originalArgName}`,
'ARG_MISSING_REQUIRED_SHORTARG'
);
}
if (isFlag) {
result[argName] = type(true, argName, result[argName]);
} else if (argStr === undefined) {
if (
argv.length < i + 2 ||
(argv[i + 1].length > 1 &&
argv[i + 1][0] === '-' &&
!(
argv[i + 1].match(/^-?\d*(\.(?=\d))?\d*$/) &&
(type === Number ||
// eslint-disable-next-line no-undef
(typeof BigInt !== 'undefined' && type === BigInt))
))
) {
const extended =
originalArgName === argName ? '' : ` (alias for ${argName})`;
throw new ArgError(
`option requires argument: ${originalArgName}${extended}`,
'ARG_MISSING_REQUIRED_LONGARG'
);
}
result[argName] = type(argv[i + 1], argName, result[argName]);
++i;
} else {
result[argName] = type(argStr, argName, result[argName]);
}
}
} else {
result._.push(wholeArg);
}
}
return result;
}
arg.flag = (fn) => {
fn[flagSymbol] = true;
return fn;
};
// Utility types
arg.COUNT = arg.flag((v, name, existingCount) => (existingCount || 0) + 1);
// Expose error class
arg.ArgError = ArgError;
module.exports = arg;