@auttam/easycli
Version:
A quick and easy way of creating cli for your npm package.
184 lines (183 loc) • 7.45 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ParamCollection = exports.Param = exports.ParamType = void 0;
const base_config_1 = require("./base-config");
const collection_1 = require("./collection");
const config_error_1 = require("../errors/config-error");
const string_1 = require("../utility/string");
const reflection_1 = require("../utility/reflection");
var ParamType;
(function (ParamType) {
ParamType["SINGLE"] = "single";
ParamType["LIST"] = "list";
})(ParamType = exports.ParamType || (exports.ParamType = {}));
class Param extends base_config_1.Config {
constructor(config) {
super(config);
this.type = ParamType.SINGLE;
this.required = false;
this.acceptOnly = [];
this.$idx = -1;
this.name = string_1.hyphenate(config.name);
this.type = config.type || this.type;
if (config.value) {
this.value = config.value;
}
this.acceptOnly = Array.isArray(config.acceptOnly) ? config.acceptOnly : [];
this.required = !!config.required;
this.acceptOnly = this.acceptOnly.filter((value, index, self) => self.indexOf(value) === index);
}
static createFromAny(config) {
return new Param({
name: config.name || '',
required: config.required,
type: config.type,
help: config.help,
value: config.value,
acceptOnly: config.acceptOnly,
propName: config.propName
});
}
}
exports.Param = Param;
class ParamCollection extends collection_1.Collection {
constructor() {
super(...arguments);
this._listParam = '';
this._optionalParam = '';
this._requiredParam = '';
this._propNames = {};
this.indexParamsParam = -1;
this.indexOptionsParam = -1;
this.indexSpreadParam = -1;
}
addByConfig(configs) {
if (this.length)
throw new config_error_1.ConfigurationError('Unable to initialize collection with properties names. Collection not empty!');
if (!Array.isArray(configs))
configs = [configs];
configs.forEach(config => {
var param = new Param(config);
super.append(param.name, new Param(config));
});
}
initByProperties(propertyNames, saveIndex) {
if (!propertyNames || !propertyNames.length)
return;
if (this.length)
throw new config_error_1.ConfigurationError('Unable to initialize collection with properties names. Collection not empty!');
for (var idx = 0; idx < propertyNames.length; idx++) {
var propName = propertyNames[idx];
var paramConfig = { name: '' };
if (propName == '$params') {
this.indexParamsParam = idx;
continue;
}
if (propName == '$options') {
this.indexOptionsParam = idx;
continue;
}
if (propName.startsWith('.')) {
propName = propName.replace('...', '');
paramConfig.type = ParamType.LIST;
this.indexSpreadParam = idx;
}
paramConfig.name = string_1.hyphenate(propName);
paramConfig.propName = propName;
var param = new Param(paramConfig);
param.$idx = idx;
super.append(param.name, param);
}
}
initByMethod(methodSignature) {
if (methodSignature && typeof methodSignature == 'function') {
this.initByProperties(reflection_1.getParameters(methodSignature));
}
}
mergeByConfigs(configs) {
if (!configs)
throw new config_error_1.ConfigurationError('Unable to merge parameter, configuration is null or undefined');
if (!Array.isArray(configs))
throw new config_error_1.ConfigurationError('Unable to merge parameter, configuration is not an array');
if (!configs.length)
return;
var existingParams = this.toArray();
this.clear();
for (var idx = 0; idx < configs.length; idx++) {
var param = existingParams[idx];
var config = configs[idx];
if (param) {
if (param.$idx > -1 && config.propName && param.propName != config.propName) {
throw new config_error_1.ConfigurationError("Unable to merge. Cannot change property name for auto-generated params", config);
}
param.merge(config, { ignoreProps: ['$idx'], insertProps: ['value'] });
param.name = config.name || param.name;
}
else {
param = new Param(config);
}
super.append(param.name, param);
}
if (configs.length < existingParams.length) {
for (var i = configs.length; i < existingParams.length; i++) {
super.append(existingParams[i].name, existingParams[i]);
}
}
}
merge(config) {
if (!config)
throw new config_error_1.ConfigurationError('Parameter configuration cannot be null or undefined');
if (super.hasKey(config.name)) {
var param = super.get(config.name);
param.merge(config);
super.update(param.name, param);
}
else {
var param = new Param(config);
super.append(param.name, param);
}
}
clear(all) {
super.clear();
this._listParam = '';
this._optionalParam = '';
this._requiredParam = '';
this._propNames = {};
if (all) {
this.indexParamsParam = -1;
this.indexOptionsParam = -1;
}
}
validate(item) {
if (this._listParam && this._listParam != item.name) {
throw new config_error_1.ConfigurationError('List type parameter already defined.', item);
}
if (item.required && this._optionalParam && this._optionalParam != item.name) {
throw new config_error_1.ConfigurationError('Required Parameter cannot be defined after optional parameter(s).', item);
}
if (this._propNames[item.propName] && this._propNames[item.propName] != item.name) {
throw new config_error_1.ConfigurationError('Unable to add param, param has a property name that is already used', item);
}
}
itemAdded(item) {
this._listParam = item.type == ParamType.LIST ? item.name : this._listParam;
this._optionalParam = !item.required ? item.name : this._optionalParam;
if (item.required) {
this._requiredParam = item.name;
}
this._propNames[item.propName] = item.name;
}
containsRequired() {
return this._requiredParam;
}
verify() {
var containsOptional = false;
for (var param of this.getItems()) {
if (containsOptional && param.required) {
throw new config_error_1.ConfigurationError('Required Parameter cannot be defined after optional parameter(s).', param);
}
containsOptional = !param.required;
}
}
}
exports.ParamCollection = ParamCollection;