@auttam/easycli
Version:
A quick and easy way of creating cli for your npm package.
211 lines (210 loc) • 9.04 kB
JavaScript
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ProgramArgs = void 0;
const settings_1 = require("../settings");
const runtime_error_1 = require("../errors/runtime-error");
const param_config_1 = require("../config/param-config");
const minimist = require('minimist');
var mappingTraps = {
get(target, prop) {
if (prop === '$has') {
return (...props) => {
if (!props)
return false;
for (var name of props) {
if (target.hasOwnProperty(name))
return true;
if (!Array.isArray(target.$unknown) && target.$unknown.hasOwnProperty(name))
return true;
}
return false;
};
}
if (!Array.isArray(target.$unknown) && prop === '$get') {
return (prop) => {
if (!prop)
return;
if (target.hasOwnProperty(prop))
return target[prop];
if (target.$unknown.hasOwnProperty(prop))
return target.$unknown[prop];
};
}
return target[prop];
}
};
class ProgramArgs {
constructor() {
this.commandName = '';
this.params = [];
this.options = null;
this.suppliedArgs = [];
this.parsedArgs = {};
}
isEmpty() {
return !this.suppliedArgs || !this.suppliedArgs.length;
}
read(argv) {
if (argv && Array.isArray(argv)) {
this.suppliedArgs = argv.slice(settings_1.SettingStore.processArgvStartIndex);
}
else {
this.suppliedArgs = process.argv.slice(settings_1.SettingStore.processArgvStartIndex);
}
if (settings_1.SettingStore.minimistOptions) {
this.parsedArgs = minimist(this.suppliedArgs, settings_1.SettingStore.minimistOptions);
}
else {
this.parsedArgs = minimist(this.suppliedArgs);
}
if (settings_1.SettingStore.enableCommands) {
this.commandName = this.parsedArgs._ && this.parsedArgs._.length ? this.parsedArgs._[0] : '';
this.parsedArgs._.shift();
}
this.params = this.parsedArgs._ || [];
delete this.parsedArgs._;
this.options = this.parsedArgs;
}
getCommandName() {
return this.commandName;
}
getParams() {
return this.params;
}
getOptions() {
return this.options;
}
optionsProvided() {
return !!Object.keys(this.options).length;
}
containsOption(name) {
if (!name)
return false;
if (!Array.isArray(name)) {
name = [name];
}
for (var item of name) {
if (typeof item == 'string' && this.options.hasOwnProperty(item))
return true;
}
return false;
}
toArray() {
return this.suppliedArgs;
}
createOptionsMap(definedOptions) {
return __awaiter(this, void 0, void 0, function* () {
var mappedOptions = {};
mappedOptions.$unknown = Object.assign({}, this.options);
if (!definedOptions || !definedOptions.length)
return new Proxy(mappedOptions, mappingTraps);
var unset = Symbol();
for (var optionInfo of definedOptions.getItems()) {
var value = unset;
if (optionInfo.name && mappedOptions.$unknown.hasOwnProperty(optionInfo.name)) {
value = mappedOptions.$unknown[optionInfo.name];
delete mappedOptions.$unknown[optionInfo.name];
}
if (value == unset && optionInfo.aliases && optionInfo.aliases.length) {
for (var alias of optionInfo.aliases) {
if (mappedOptions.$unknown.hasOwnProperty(alias)) {
value = mappedOptions.$unknown[alias];
delete mappedOptions.$unknown[alias];
}
}
}
if (value == unset && typeof optionInfo.value != "undefined") {
value = optionInfo.value;
}
if (value != unset && typeof optionInfo.value != "undefined" && typeof value != typeof optionInfo.value) {
value = optionInfo.value;
}
if (value != unset) {
value = this.getAcceptedValue(value, optionInfo);
}
if (value != unset) {
mappedOptions[optionInfo.propName] = value;
}
}
Object.seal(mappedOptions);
return new Proxy(mappedOptions, mappingTraps);
});
}
createParamsMap(definedParams) {
return __awaiter(this, void 0, void 0, function* () {
var mappedParams = {};
mappedParams.$unknown = Array.from(this.params);
if (!definedParams || !definedParams.length) {
return new Proxy(mappedParams, mappingTraps);
}
var currentParamListIdx = 0;
for (var paramInfo of definedParams.getItems()) {
if (!paramInfo.name)
return;
if (!this.params.length || currentParamListIdx >= this.params.length) {
if (paramInfo.required && typeof paramInfo.value == 'undefined') {
throw new runtime_error_1.RuntimeError('Required parameter missing', paramInfo);
}
break;
}
mappedParams[paramInfo.propName] = paramInfo.value || '';
if (paramInfo.type == param_config_1.ParamType.SINGLE) {
mappedParams[paramInfo.propName] = this.params[currentParamListIdx];
currentParamListIdx++;
}
if (paramInfo.type == param_config_1.ParamType.LIST) {
mappedParams[paramInfo.propName] = this.params.slice(currentParamListIdx);
currentParamListIdx = this.params.length;
}
if (paramInfo.required && !mappedParams[paramInfo.propName]) {
throw new runtime_error_1.RuntimeError('Required parameter missing', paramInfo);
}
mappedParams[paramInfo.propName] = this.getAcceptedValue(mappedParams[paramInfo.propName], paramInfo);
}
mappedParams.$unknown = mappedParams.$unknown.slice(currentParamListIdx);
Object.seal(mappedParams);
return new Proxy(mappedParams, mappingTraps);
});
}
getAcceptedValue(value, infoObject) {
if (!value || !infoObject)
return value;
if (infoObject.acceptOnly && Array.isArray(infoObject.acceptOnly) && infoObject.acceptOnly.length) {
var acceptOnly = infoObject.acceptOnly.map((value) => value.toLowerCase());
var matchedValue;
if (Array.isArray(value) && value.length) {
matchedValue = [];
for (var eachValue of value) {
var idx = acceptOnly.indexOf(eachValue.toLowerCase());
if (idx > -1) {
matchedValue.push(infoObject.acceptOnly[idx]);
}
}
}
if (!Array.isArray(value) && typeof value == "string") {
var idx = acceptOnly.indexOf(value.toLowerCase());
if (idx > -1) {
matchedValue = infoObject.acceptOnly[idx];
}
}
if (!matchedValue && typeof infoObject.value != 'undefined') {
matchedValue = infoObject.value;
}
if (!matchedValue) {
throw new runtime_error_1.RuntimeError(`Incorrect supplied value for parameter`, infoObject);
}
return matchedValue;
}
return value;
}
}
exports.ProgramArgs = ProgramArgs;