@kubiklabs/wasmkit
Version:
Wasmkit is a development environment to compile, deploy, test, run cosmwasm contracts on different networks.
191 lines (190 loc) • 7.84 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ArgumentsParser = void 0;
const errors_1 = require("../core/errors");
const errors_list_1 = require("../core/errors-list");
class ArgumentsParser {
static paramNameToCLA(paramName) {
return (ArgumentsParser.PARAM_PREFIX +
paramName
.split(/(?=[A-Z])/g)
.map((s) => s.toLowerCase())
.join("-"));
}
static shortParamNameToCLA(paramName) {
if (paramName) {
return ArgumentsParser.SHORT_PARAM_PREFIX + paramName;
}
return "";
}
static cLAToParamName(cLA) {
if (cLA.toLowerCase() !== cLA) {
throw new errors_1.WasmkitError(errors_list_1.ERRORS.ARGUMENTS.PARAM_NAME_INVALID_CASING, {
param: cLA
});
}
const parts = cLA.slice(ArgumentsParser.PARAM_PREFIX.length).split("-");
return (parts[0] +
parts
.slice(1)
.map((s) => s[0].toUpperCase() + s.slice(1))
.join(""));
}
_substituteShortParam(arg, shortParamSubs) {
if (this._hasShortParamNameFormat(arg)) {
const substitution = shortParamSubs[arg.substr(1)];
if (substitution) {
return ArgumentsParser.PARAM_PREFIX + substitution;
}
}
return arg;
}
parseRuntimeArgs(paramDefs, shortParamSubs, envVariableArguments, rawCLAs) {
const runtimeArgs = {};
let taskName;
const unparsedCLAs = [];
for (let i = 0; i < rawCLAs.length; i++) {
rawCLAs[i] = this._substituteShortParam(rawCLAs[i], shortParamSubs);
const arg = rawCLAs[i];
if (taskName === undefined) {
if (!this._hasCLAParamNameFormat(arg)) {
taskName = arg;
continue;
}
if (!this._isCLAParamName(arg, paramDefs)) {
throw new errors_1.WasmkitError(errors_list_1.ERRORS.ARGUMENTS.UNRECOGNIZED_COMMAND_LINE_ARG, { argument: arg });
}
}
else {
if (!this._isCLAParamName(arg, paramDefs)) {
unparsedCLAs.push(arg);
continue;
}
}
i = this._parseArgumentAt(rawCLAs, i, paramDefs, runtimeArgs);
}
return {
runtimeArgs: this._addBuilderDefaultArguments(paramDefs, envVariableArguments, runtimeArgs),
taskName,
unparsedCLAs
};
}
parseTaskArguments(taskDefinition, rawCLAs) {
const { paramArguments, rawPositionalArguments } = this._parseTaskParamArguments(taskDefinition, rawCLAs);
const positionalArguments = this._parsePositionalParamArgs(rawPositionalArguments, taskDefinition.positionalParamDefinitions);
return { ...paramArguments, ...positionalArguments };
}
_parseTaskParamArguments(taskDefinition, rawCLAs
// eslint-disable-next-line
) {
const paramArguments = {};
const rawPositionalArguments = [];
for (let i = 0; i < rawCLAs.length; i++) {
const arg = rawCLAs[i];
if (!this._hasCLAParamNameFormat(arg)) {
rawPositionalArguments.push(arg);
continue;
}
if (!this._isCLAParamName(arg, taskDefinition.paramDefinitions)) {
throw new errors_1.WasmkitError(errors_list_1.ERRORS.ARGUMENTS.UNRECOGNIZED_PARAM_NAME, {
param: arg
});
}
i = this._parseArgumentAt(rawCLAs, i, taskDefinition.paramDefinitions, paramArguments);
}
this._addTaskDefaultArguments(taskDefinition, paramArguments);
return { paramArguments, rawPositionalArguments };
}
_addBuilderDefaultArguments(paramDefs, envVariableArguments, runtimeArgs) {
return {
...envVariableArguments,
...runtimeArgs
};
}
_addTaskDefaultArguments(taskDefinition, taskArguments) {
for (const paramName of Object.keys(taskDefinition.paramDefinitions)) {
const definition = taskDefinition.paramDefinitions[paramName];
if (taskArguments[paramName] !== undefined) {
continue;
}
if (!definition.isOptional) {
throw new errors_1.WasmkitError(errors_list_1.ERRORS.ARGUMENTS.MISSING_TASK_ARGUMENT, {
param: ArgumentsParser.paramNameToCLA(paramName)
});
}
taskArguments[paramName] = definition.defaultValue;
}
}
_isCLAParamName(str, paramDefinitions) {
if (!this._hasCLAParamNameFormat(str)) {
return false;
}
const name = ArgumentsParser.cLAToParamName(str);
return paramDefinitions[name] !== undefined;
}
_hasCLAParamNameFormat(str) {
return str.startsWith(ArgumentsParser.PARAM_PREFIX);
}
_hasShortParamNameFormat(str) {
return str.startsWith(ArgumentsParser.SHORT_PARAM_PREFIX) && str.length === 2;
}
_parseArgumentAt(rawCLAs, index, paramDefinitions, parsedArguments) {
const claArg = rawCLAs[index];
const paramName = ArgumentsParser.cLAToParamName(claArg);
const definition = paramDefinitions[paramName];
if (parsedArguments[paramName] !== undefined) {
throw new errors_1.WasmkitError(errors_list_1.ERRORS.ARGUMENTS.REPEATED_PARAM, {
param: claArg
});
}
if (definition.isFlag) {
parsedArguments[paramName] = true;
}
else {
index++;
const value = rawCLAs[index];
if (value === undefined) {
throw new errors_1.WasmkitError(errors_list_1.ERRORS.ARGUMENTS.MISSING_TASK_ARGUMENT, {
param: ArgumentsParser.paramNameToCLA(paramName)
});
}
parsedArguments[paramName] = definition.type.parse(paramName, value);
}
return index;
}
_parsePositionalParamArgs(rawPositionalParamArgs, positionalParamDefinitions // eslint-disable-line @typescript-eslint/no-explicit-any
) {
const args = {};
for (let i = 0; i < positionalParamDefinitions.length; i++) {
const definition = positionalParamDefinitions[i];
const rawArg = rawPositionalParamArgs[i];
if (rawArg === undefined) {
if (!definition.isOptional) {
throw new errors_1.WasmkitError(errors_list_1.ERRORS.ARGUMENTS.MISSING_POSITIONAL_ARG, {
param: definition.name
});
}
args[definition.name] = definition.defaultValue;
}
else if (!definition.isVariadic) {
args[definition.name] = definition.type.parse(definition.name, rawArg);
}
else {
args[definition.name] = rawPositionalParamArgs
.slice(i)
.map((raw) => definition.type.parse(definition.name, raw));
}
}
const hasVariadicParam = positionalParamDefinitions[positionalParamDefinitions.length - 1]?.isVariadic;
if (!hasVariadicParam &&
rawPositionalParamArgs.length > positionalParamDefinitions.length) {
throw new errors_1.WasmkitError(errors_list_1.ERRORS.ARGUMENTS.UNRECOGNIZED_POSITIONAL_ARG, {
argument: rawPositionalParamArgs[positionalParamDefinitions.length]
});
}
return args;
}
}
exports.ArgumentsParser = ArgumentsParser;
ArgumentsParser.PARAM_PREFIX = "--";
ArgumentsParser.SHORT_PARAM_PREFIX = "-";