@rushstack/heft
Version:
Build all your JavaScript projects the same way: A way that works.
224 lines • 11.6 kB
JavaScript
;
// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
// See LICENSE in the project root for license information.
Object.defineProperty(exports, "__esModule", { value: true });
exports.HeftParameterManager = void 0;
const node_core_library_1 = require("@rushstack/node-core-library");
const ts_command_line_1 = require("@rushstack/ts-command-line");
class HeftParameterManager {
get defaultParameters() {
if (!this._isFinalized) {
throw new node_core_library_1.InternalError('Parameters have not yet been finalized.');
}
if (!this._defaultParameters) {
this._defaultParameters = {
clean: this._options.getIsClean(),
debug: this._options.getIsDebug(),
verbose: this._options.getIsVerbose(),
production: this._options.getIsProduction(),
locales: this._options.getLocales(),
watch: this._options.getIsWatch()
};
}
return this._defaultParameters;
}
constructor(options) {
// plugin definition => parameter accessors and defaults
this._heftParametersByDefinition = new Map();
// plugin definition => Map< parameter long name => applied parameter >
this._parametersByDefinition = new Map();
// parameter scope => plugin definition
this._pluginDefinitionsByScope = new Map();
this._isFinalized = false;
this._options = options;
}
/**
* Add parameters provided by the specified plugin definition. Parameters will be registered with the
* command line parameter provider after finalization.
*/
addPluginParameters(pluginDefinition) {
if (this._isFinalized) {
throw new node_core_library_1.InternalError('Parameters have already been finalized.');
}
if (!this._parametersByDefinition.has(pluginDefinition)) {
this._parametersByDefinition.set(pluginDefinition, new Map());
}
}
/**
* Finalize and register parameters with the specified parameter provider. The parameter manager
* can only be finalized once.
*/
finalizeParameters(commandLineParameterProvider) {
if (this._isFinalized) {
throw new node_core_library_1.InternalError('Parameters have already been finalized.');
}
this._isFinalized = true;
for (const pluginDefinition of this._parametersByDefinition.keys()) {
this._addParametersToProvider(pluginDefinition, commandLineParameterProvider);
}
}
/**
* Get the finalized parameters for the specified plugin definition.
*/
getParametersForPlugin(pluginDefinition) {
if (!this._isFinalized) {
throw new node_core_library_1.InternalError('Parameters have not yet been finalized.');
}
let heftParameters = this._heftParametersByDefinition.get(pluginDefinition);
if (!heftParameters) {
const parameters = this._parametersByDefinition.get(pluginDefinition);
if (!parameters) {
throw new node_core_library_1.InternalError(`Parameters from plugin ${JSON.stringify(pluginDefinition.pluginName)} in package ` +
`${JSON.stringify(pluginDefinition.pluginPackageName)} were not added before finalization.`);
}
heftParameters = {
...this.defaultParameters,
getChoiceParameter: (parameterLongName) => this._getParameter(parameters, parameterLongName, ts_command_line_1.CommandLineParameterKind.Choice),
getChoiceListParameter: (parameterLongName) => this._getParameter(parameters, parameterLongName, ts_command_line_1.CommandLineParameterKind.ChoiceList),
getFlagParameter: (parameterLongName) => this._getParameter(parameters, parameterLongName, ts_command_line_1.CommandLineParameterKind.Flag),
getIntegerParameter: (parameterLongName) => this._getParameter(parameters, parameterLongName, ts_command_line_1.CommandLineParameterKind.Integer),
getIntegerListParameter: (parameterLongName) => this._getParameter(parameters, parameterLongName, ts_command_line_1.CommandLineParameterKind.IntegerList),
getStringParameter: (parameterLongName) => this._getParameter(parameters, parameterLongName, ts_command_line_1.CommandLineParameterKind.String),
getStringListParameter: (parameterLongName) => this._getParameter(parameters, parameterLongName, ts_command_line_1.CommandLineParameterKind.StringList)
};
this._heftParametersByDefinition.set(pluginDefinition, heftParameters);
}
return heftParameters;
}
/**
* Add the parameters specified by a plugin definition to the command line parameter provider.
* Duplicate parameters are allowed, as long as they have different parameter scopes. In this
* case, the parameter will only be referenceable by the CLI argument
* "--<parameterScope>:<parameterName>". If there is no duplicate parameter, it will also be
* referenceable by the CLI argument "--<parameterName>".
*/
_addParametersToProvider(pluginDefinition, commandLineParameterProvider) {
const { pluginName, pluginPackageName, pluginParameterScope: parameterScope, pluginParameters } = pluginDefinition;
const existingDefinitionWithScope = this._pluginDefinitionsByScope.get(parameterScope);
if (existingDefinitionWithScope && existingDefinitionWithScope !== pluginDefinition) {
const { pluginName: existingScopePluginName, pluginPackageName: existingScopePluginPackageName } = existingDefinitionWithScope;
throw new Error(`Plugin ${JSON.stringify(pluginName)} in package ` +
`${JSON.stringify(pluginPackageName)} specifies the same parameter scope ` +
`${JSON.stringify(parameterScope)} as plugin ` +
`${JSON.stringify(existingScopePluginName)} from package ` +
`${JSON.stringify(existingScopePluginPackageName)}.`);
}
else {
this._pluginDefinitionsByScope.set(parameterScope, pluginDefinition);
}
const definedPluginParametersByName = this._parametersByDefinition.get(pluginDefinition);
for (const parameter of pluginParameters) {
let definedParameter;
const { description, required, longName: parameterLongName, shortName: parameterShortName } = parameter;
switch (parameter.parameterKind) {
case 'choiceList': {
const { alternatives } = parameter;
definedParameter = commandLineParameterProvider.defineChoiceListParameter({
description,
required,
alternatives: alternatives.map((p) => p.name),
parameterLongName,
parameterShortName,
parameterScope
});
break;
}
case 'choice': {
const { alternatives, defaultValue } = parameter;
definedParameter = commandLineParameterProvider.defineChoiceParameter({
description,
required,
alternatives: alternatives.map((p) => p.name),
defaultValue,
parameterLongName,
parameterShortName,
parameterScope
});
break;
}
case 'flag': {
definedParameter = commandLineParameterProvider.defineFlagParameter({
description,
required,
parameterLongName,
parameterShortName,
parameterScope
});
break;
}
case 'integerList': {
const { argumentName } = parameter;
definedParameter = commandLineParameterProvider.defineIntegerListParameter({
description,
required,
argumentName,
parameterLongName,
parameterShortName,
parameterScope
});
break;
}
case 'integer': {
const { argumentName, defaultValue } = parameter;
definedParameter = commandLineParameterProvider.defineIntegerParameter({
description,
required,
argumentName,
defaultValue,
parameterLongName,
parameterShortName,
parameterScope
});
break;
}
case 'stringList': {
const { argumentName } = parameter;
definedParameter = commandLineParameterProvider.defineStringListParameter({
description,
required,
argumentName,
parameterLongName,
parameterShortName,
parameterScope
});
break;
}
case 'string': {
const { argumentName, defaultValue } = parameter;
definedParameter = commandLineParameterProvider.defineStringParameter({
description,
required,
argumentName,
defaultValue,
parameterLongName,
parameterShortName,
parameterScope
});
break;
}
default: {
// Need to cast to IParameterJson since it's inferred to be type 'never'
throw new node_core_library_1.InternalError(`Unrecognized parameter kind: ${parameter.parameterKind}`);
}
}
// Add the parameter to the map using the original long name, so that it can be retrieved by plugins
// under the original long name.
definedPluginParametersByName.set(parameter.longName, definedParameter);
}
}
_getParameter(parametersByLongName, parameterLongName, expectedParameterKind) {
const parameter = parametersByLongName.get(parameterLongName);
if (!parameter) {
throw new Error(`Parameter ${JSON.stringify(parameterLongName)} not found. Are you sure it was defined in ` +
'heft-plugin.json?');
}
else if (parameter.kind !== expectedParameterKind) {
throw new Error(`Parameter ${JSON.stringify(parameterLongName)} is of kind ` +
`${JSON.stringify(ts_command_line_1.CommandLineParameterKind[parameter.kind])}, not of kind ` +
`${JSON.stringify(ts_command_line_1.CommandLineParameterKind[expectedParameterKind])}.`);
}
return parameter;
}
}
exports.HeftParameterManager = HeftParameterManager;
//# sourceMappingURL=HeftParameterManager.js.map