@nu-art/commando 0.203.117

package/cli/basic.d.ts

@@ -0,0 +1,48 @@
+import { CliBlock, CliWrapper } from '../core/cli';
+type Cli_EchoOptions = {
+    escape?: boolean;
+    toFile?: {
+        name: string;
+        append?: boolean;
+    };
+};
+/**
+ * Represents a Command Line Interface (CLI) to build and execute shell commands.
+ */
+export declare class Cli_Basic extends CliWrapper {
+    /**
+     * Changes directory and optionally executes a block of commands in that directory.
+     * @param {string} folderName - Name of the directory to change to.
+     * @param {CliBlock} [toRun] - Optional block of commands to execute in the directory.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    cd(folderName: string, toRun?: CliBlock<this>): this;
+    custom(command: string): this;
+    /**
+     * Changes directory back to the previous directory.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    cd_(): this;
+    /**
+     * Appends an 'ls' command with optional parameters.
+     * @param {string} [params] - Optional parameters for the 'ls' command.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    ls(params?: string): this;
+    mkdir(dirName: string): this;
+    cat(fileName: string): this;
+    echo(log: string, options?: Cli_EchoOptions): this;
+    /**
+     * Appends a 'pwd' command to print the current directory.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    pwd(): this;
+    /**
+     * Assigns a value to a variable in the script.
+     * @param {string} varName - The name of the variable.
+     * @param {string | string[]} value - The value to assign to the variable.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    assignVar(varName: string, value: string | string[]): this;
+}
+export {};

package/cli/basic.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cli_Basic = void 0;
+const cli_1 = require("../core/cli");
+/**
+ * Represents a Command Line Interface (CLI) to build and execute shell commands.
+ */
+class Cli_Basic extends cli_1.CliWrapper {
+    /**
+     * Changes directory and optionally executes a block of commands in that directory.
+     * @param {string} folderName - Name of the directory to change to.
+     * @param {CliBlock} [toRun] - Optional block of commands to execute in the directory.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    cd(folderName, toRun) {
+        this.cli.append(`cd ${folderName}`);
+        this.cli.indentIn();
+        if (toRun) {
+            toRun(this);
+            this.cd_();
+        }
+        return this;
+    }
+    custom(command) {
+        this.cli.append(command);
+        return this;
+    }
+    /**
+     * Changes directory back to the previous directory.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    cd_() {
+        this.cli.indentOut();
+        this.cli.append(`cd -`);
+        return this;
+    }
+    /**
+     * Appends an 'ls' command with optional parameters.
+     * @param {string} [params] - Optional parameters for the 'ls' command.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    ls(params = '') {
+        this.cli.append(`ls ${params}`);
+        return this;
+    }
+    mkdir(dirName) {
+        this.cli.append(`mkdir -p ${dirName}`);
+        return this;
+    }
+    cat(fileName) {
+        this.cli.append(`cat ${fileName}`);
+        return this;
+    }
+    echo(log, options) {
+        const _escape = (options === null || options === void 0 ? void 0 : options.escape) ? '-e' : '';
+        const _toFile = (options === null || options === void 0 ? void 0 : options.toFile) ? `>${options.toFile.append ? '>' : ''} ${options.toFile.name}` : '';
+        const escapedLog = log.replace(/\\/g, '\\\\').replace(/\n/g, '\\\\n').replace(/\t/g, '\\\t');
+        this.cli.append(`echo ${_escape} "${escapedLog}" ${_toFile}`);
+        return this;
+    }
+    /**
+     * Appends a 'pwd' command to print the current directory.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    pwd() {
+        this.cli.append('pwd');
+        return this;
+    }
+    /**
+     * Assigns a value to a variable in the script.
+     * @param {string} varName - The name of the variable.
+     * @param {string | string[]} value - The value to assign to the variable.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    assignVar(varName, value) {
+        this.cli.append(`${varName}=(${Array.isArray(value) ? value : [value].join(' ')})`);
+        return this;
+    }
+}
+exports.Cli_Basic = Cli_Basic;

package/cli/cli-params.d.ts

@@ -0,0 +1,51 @@
+import { Primitive, TypeOfTypeAsString } from '@nu-art/ts-common';
+export declare const DefaultProcessor_Boolean: CliParam<any, boolean>['process'];
+export declare const DefaultProcessor_String: CliParam<any, string>['process'];
+export declare const DefaultProcessor_Number: CliParam<any, number>['process'];
+export type CliParams<T extends BaseCliParam<string, any>[]> = {
+    [K in T[number]['keyName']]: NonNullable<Extract<T[number], {
+        keyName: K;
+    }>['defaultValue']>;
+};
+export type BaseCliParam<K extends string, V extends Primitive | Primitive[]> = {
+    keys: string[];
+    keyName: K;
+    type: TypeOfTypeAsString<V>;
+    description: string;
+    name?: string;
+    options?: string[];
+    defaultValue?: V;
+    process?: (value?: string, defaultValue?: V) => V;
+    isArray?: true;
+    group?: string;
+};
+export type CliParam<K extends string, V extends Primitive | Primitive[]> = BaseCliParam<K, V> & {
+    name: string;
+    process: (value?: string, defaultValue?: V) => V;
+};
+export declare class CLIParams_Resolver<T extends BaseCliParam<string, any>[], Output extends CliParams<T> = CliParams<T>> {
+    private params;
+    static create<T extends BaseCliParam<string, any>[]>(...params: T): CLIParams_Resolver<T, CliParams<T>>;
+    constructor(params: BaseCliParam<string, any>[]);
+    /**
+     * Format current input params and return it structured by the app params type.
+     * @param inputParams current console input arguments
+     * @returns CliParamsObject
+     */
+    resolveParamValue(inputParams?: string[]): Output;
+    /**
+     * Find the matching param by finding it's key in the current argument
+     * Go over the app params and find the CLIParam object representing it
+     * @param inputParam The current console argument being parsed
+     * @returns The CliParam or undefined if not found
+     * @private
+     */
+    private findMatchingParamToResolve;
+    /**
+     * Translate BaseCLIParams passed to the constructor to CLIParams
+     * @param params User input of CLI params being passed to the constructor
+     * @private
+     * @returns CLI Params filled with all mandatory data
+     */
+    private translate;
+}

package/cli/cli-params.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIParams_Resolver = exports.DefaultProcessor_Number = exports.DefaultProcessor_String = exports.DefaultProcessor_Boolean = void 0;
+const ts_common_1 = require("@nu-art/ts-common");
+const DefaultProcessor_Boolean = (input, defaultValue) => {
+    return true;
+};
+exports.DefaultProcessor_Boolean = DefaultProcessor_Boolean;
+const DefaultProcessor_String = (input, defaultValue) => {
+    if (!input || !input.length) {
+        if (!defaultValue)
+            throw new Error('expected string value');
+        return defaultValue;
+    }
+    return input;
+};
+exports.DefaultProcessor_String = DefaultProcessor_String;
+const DefaultProcessor_Number = (input, defaultValue) => {
+    if (!input) {
+        if (!defaultValue)
+            throw new Error('expected number value');
+        return defaultValue;
+    }
+    if (isNaN(Number(input)))
+        throw new Error('expected number value');
+    return Number(input);
+};
+exports.DefaultProcessor_Number = DefaultProcessor_Number;
+const DefaultProcessorsMapper = {
+    string: exports.DefaultProcessor_String,
+    boolean: exports.DefaultProcessor_Boolean,
+    number: exports.DefaultProcessor_Number,
+};
+class CLIParams_Resolver {
+    static create(...params) {
+        return new CLIParams_Resolver(params);
+    }
+    constructor(params) {
+        this.params = this.translate(params);
+    }
+    /**
+     * Format current input params and return it structured by the app params type.
+     * @param inputParams current console input arguments
+     * @returns CliParamsObject
+     */
+    resolveParamValue(inputParams = process.argv.slice(2, process.argv.length)) {
+        return inputParams.reduce((output, inputParam) => {
+            const cliParamToResolve = this.findMatchingParamToResolve(inputParam);
+            if (!cliParamToResolve)
+                return output;
+            const value = inputParam.split('=')[1];
+            const finalValue = cliParamToResolve.process(value, cliParamToResolve.defaultValue);
+            // validate options if exits
+            if (cliParamToResolve.options && !cliParamToResolve.options.includes(value))
+                throw new Error('value not supported for this param');
+            //TODO: OPTIMIZE THIS IS PURE JS
+            const key = cliParamToResolve.keyName;
+            if (cliParamToResolve.isArray) {
+                let currentValues = output[key];
+                currentValues = (0, ts_common_1.filterDuplicates)([...currentValues !== null && currentValues !== void 0 ? currentValues : [], finalValue]);
+                output[key] = currentValues;
+                return output;
+            }
+            //if already exists and the value ain't an array warn that the value will be overridden
+            if (output[key])
+                ts_common_1.StaticLogger.logWarning(`this param does not accept multiple values, overriding prev value: ${output[key]}`);
+            //Apply single value to the object
+            output[key] = finalValue;
+            return output;
+        }, {});
+    }
+    /**
+     * Find the matching param by finding it's key in the current argument
+     * Go over the app params and find the CLIParam object representing it
+     * @param inputParam The current console argument being parsed
+     * @returns The CliParam or undefined if not found
+     * @private
+     */
+    findMatchingParamToResolve(inputParam) {
+        let maxKeyLength = 0;
+        let matchingParam;
+        // look for the longest fitting param in order to make sure we find the perfect match
+        this.params.forEach((param) => {
+            param.keys.forEach((key) => {
+                if (inputParam.startsWith(key) && key.length > maxKeyLength) {
+                    maxKeyLength = key.length;
+                    matchingParam = param;
+                }
+            });
+        });
+        return matchingParam;
+    }
+    /**
+     * Translate BaseCLIParams passed to the constructor to CLIParams
+     * @param params User input of CLI params being passed to the constructor
+     * @private
+     * @returns CLI Params filled with all mandatory data
+     */
+    translate(params) {
+        return params.map(param => {
+            //If name is not defined apply key name as the param name
+            if (!param.name)
+                param.name = param.keyName;
+            //If no processor is passed apply default by type
+            if (!param.process) {
+                param.process = DefaultProcessorsMapper[param.type.split('[')[0].trim()];
+            }
+            //Determine if value is array by the param type TODO: improve this chunk of code, this is not strict enough
+            if (!(0, ts_common_1.exists)(param.isArray) && param.type.includes('[]'))
+                param.isArray = true;
+            return param;
+        });
+    }
+}
+exports.CLIParams_Resolver = CLIParams_Resolver;

package/cli/git.d.ts

@@ -0,0 +1,53 @@
+import { Cli_Programming } from './programming';
+import { Cli_Basic } from './basic';
+declare const Super: new (...args: any[]) => Cli_Programming & Cli_Basic;
+type GitCloneParams = {
+    outputFolder?: string;
+    branch?: string;
+    recursive?: boolean;
+};
+type GitPushParams = {
+    remote: string;
+    branch: string;
+    tags?: boolean;
+    force?: boolean;
+};
+export declare class Cli_Git extends Super {
+    git: {
+        clone: (url: string, options?: GitCloneParams) => Cli_Git;
+        checkout: (branch: string) => Cli_Git;
+        createTag: (tagName: string) => Cli_Git;
+        gitCommit: (commitMessage: string) => Cli_Git;
+        add: (file: string) => Cli_Git;
+        addAll: () => Cli_Git;
+        addAndCommit: (commitMessage: string) => Cli_Git;
+        push: (options?: GitPushParams) => Cli_Git;
+        pushTags: () => Cli_Git;
+        fetch: () => Cli_Git;
+        resetHard: (tag?: string) => Cli_Git;
+        getCurrentBranch: () => Cli_Git;
+        pull: (params: string) => Cli_Git;
+        merge: (mergeFrom: string) => Cli_Git;
+        createBranch: (branch: string) => Cli_Git;
+        gsui: (modules?: string) => Cli_Git;
+        status: () => Cli_Git;
+    };
+    private git_clone;
+    private git_checkout;
+    private git_createTag;
+    private git_gitCommit;
+    private git_add;
+    private git_addAll;
+    private git_addAndCommit;
+    private git_push;
+    private git_pushTags;
+    private git_fetch;
+    private git_resetHard;
+    private git_getCurrentBranch;
+    private git_pull;
+    private git_merge;
+    private git_createBranch;
+    private git_gsui;
+    private git_status;
+}
+export {};

package/cli/git.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cli_Git = void 0;
+const programming_1 = require("./programming");
+const class_merger_1 = require("../core/class-merger");
+const basic_1 = require("./basic");
+const Super = (0, class_merger_1.MergeClass)(programming_1.Cli_Programming, basic_1.Cli_Basic);
+class Cli_Git extends Super {
+    constructor() {
+        super(...arguments);
+        this.git = {
+            clone: this.git_clone,
+            checkout: this.git_checkout,
+            createTag: this.git_createTag,
+            gitCommit: this.git_gitCommit,
+            add: this.git_add,
+            addAll: this.git_addAll,
+            addAndCommit: this.git_addAndCommit,
+            push: this.git_push,
+            pushTags: this.git_pushTags,
+            fetch: this.git_fetch,
+            resetHard: this.git_resetHard,
+            getCurrentBranch: this.git_getCurrentBranch,
+            pull: this.git_pull,
+            merge: this.git_merge,
+            createBranch: this.git_createBranch,
+            gsui: this.git_gsui,
+            status: this.git_status,
+        };
+    }
+    git_clone(url, options) {
+        const branch = `${(options === null || options === void 0 ? void 0 : options.branch) ? ` -b ${options === null || options === void 0 ? void 0 : options.branch}` : ''}`;
+        const recursive = `${(options === null || options === void 0 ? void 0 : options.recursive) ? ` --recursive` : ''}`;
+        const outputFolder = `${(options === null || options === void 0 ? void 0 : options.outputFolder) ? ` ${options.outputFolder}` : ''}`;
+        this.cli.append(`git clone${recursive}${branch} ${url}${outputFolder}`);
+        return this;
+    }
+    git_checkout(branch) {
+        this.cli.append(`git checkout ${branch}`);
+        return this;
+    }
+    git_createTag(tagName) {
+        this.cli.append(`git tag -f ${tagName}`);
+        return this;
+    }
+    git_gitCommit(commitMessage) {
+        this.cli.append(`git commit -m "${commitMessage}"`);
+        return this;
+    }
+    git_add(file) {
+        this.cli.append(`git add "${file}"`);
+        return this;
+    }
+    git_addAll() {
+        this.cli.append(`git add .`);
+        return this;
+    }
+    git_addAndCommit(commitMessage) {
+        this.cli.append(`git commit -am "${commitMessage}"`);
+        return this;
+    }
+    git_push(options) {
+        this.cli.append(`git push ${options === null || options === void 0 ? void 0 : options.remote} ${options === null || options === void 0 ? void 0 : options.branch}`);
+        return this;
+    }
+    git_pushTags() {
+        this.cli.append('git push --tags --force');
+        return this;
+    }
+    git_fetch() {
+        this.cli.append('git fetch');
+        return this;
+    }
+    git_resetHard(tag = '') {
+        this.cli.append('git reset --hard ${tag}');
+        return this;
+    }
+    git_getCurrentBranch() {
+        this.cli.append('git status | grep "On branch" | sed -E "s');
+        return this;
+    }
+    git_pull(params) {
+        this.cli.append('git pull ${params}');
+        return this;
+    }
+    git_merge(mergeFrom) {
+        this.cli.append(`git merge ${mergeFrom}`);
+        return this;
+    }
+    git_createBranch(branch) {
+        this.cli.append(`git checkout - b ${branch}`);
+        this.cli.append(`git push-- set -upstream origin ${branch}`);
+        return this;
+    }
+    git_gsui(modules = '') {
+        this.cli.append('git submodule update --recursive --init ${modules}');
+        return this;
+    }
+    git_status() {
+        this.cli.append('git status');
+        return this;
+    }
+}
+exports.Cli_Git = Cli_Git;

package/cli/nvm.d.ts

@@ -0,0 +1,22 @@
+import { CliWrapper, Commando, CommandoInteractive } from '../core/cli';
+import { Constructor, Logger } from '@nu-art/ts-common';
+export declare class Cli_NVM extends Logger {
+    private _expectedVersion;
+    private _homeEnvVar;
+    constructor();
+    get homeEnvVar(): string;
+    set homeEnvVar(value: string);
+    get expectedVersion(): string;
+    set expectedVersion(value: string);
+    install: () => Promise<boolean | this | undefined>;
+    isInstalled: () => boolean;
+    getRequiredNode_Version: () => Promise<string>;
+    installRequiredVersionIfNeeded: () => Promise<boolean>;
+    getInstalledNode_Versions: () => Promise<(string | undefined)[]>;
+    private getVersion;
+    uninstall: () => Promise<void>;
+    private installVersion;
+    createInteractiveCommando<T extends Constructor<CliWrapper>[]>(...plugins: T): CommandoInteractive & Commando & import("../core/class-merger").MergeTypes<T>;
+    createCommando<T extends Constructor<CliWrapper>[]>(...plugins: T): Commando & import("../core/class-merger").MergeTypes<T>;
+}
+export declare const NVM: Cli_NVM;

package/cli/nvm.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NVM = exports.Cli_NVM = void 0;
+const programming_1 = require("./programming");
+const basic_1 = require("./basic");
+const cli_1 = require("../core/cli");
+const fs = require("fs");
+const fs_1 = require("fs");
+const path = require("path");
+const tools_1 = require("../core/tools");
+const ts_common_1 = require("@nu-art/ts-common");
+const CONST__FILE_NVMRC = '.nvmrc';
+class Cli_NVM extends ts_common_1.Logger {
+    constructor() {
+        super();
+        this._expectedVersion = '0.35.3';
+        this._homeEnvVar = '$NVM_DIR';
+        this.install = async () => {
+            if (this.isInstalled()) {
+                const version = (await this.getVersion()).stdout.trim();
+                if (this._expectedVersion === version)
+                    return;
+                await this.uninstall();
+            }
+            await cli_1.Commando.create()
+                .append(`  curl -o- "https://raw.githubusercontent.com/nvm-sh/nvm/v${this._expectedVersion}/install.sh" | bash`)
+                .execute();
+            const rcFile = path.resolve(process.env['HOME'], '.bashrc');
+            let rcFileContent = '';
+            if (fs.existsSync(rcFile)) {
+                rcFileContent = await fs_1.promises.readFile(rcFile, { encoding: 'utf8' });
+                return rcFileContent.includes('NVM_DIR');
+            }
+            rcFileContent = `${rcFileContent}\n${rcFileContent.endsWith('\n') ? '' : '\n'}`;
+            rcFileContent += `# generated NVM - start\n`;
+            rcFileContent += `echo 'export NVM_DIR="$HOME/.nvm"'\n`;
+            rcFileContent += `echo '[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm'\n`;
+            rcFileContent += `echo '[ -s "$NVM_DIR/bash_completion" ] && \\. "$NVM_DIR/bash_completion"  # This loads nvm bash_completion'\n`;
+            rcFileContent += `# generated NVM - end\n`;
+            await fs_1.promises.writeFile(rcFile, rcFileContent, { encoding: 'utf8' });
+            return this;
+        };
+        this.isInstalled = () => !!process.env[this._homeEnvVar] && fs.existsSync(process.env[this._homeEnvVar]);
+        this.getRequiredNode_Version = async () => {
+            const absolutePathToNvmrcFile = path.resolve(CONST__FILE_NVMRC);
+            if (!fs.existsSync(absolutePathToNvmrcFile))
+                throw new Error(`couldn't find .nvmrc file at: ${absolutePathToNvmrcFile}`);
+            const content = await fs_1.promises.readFile(absolutePathToNvmrcFile, { encoding: 'utf-8' });
+            return content.trim();
+        };
+        this.installRequiredVersionIfNeeded = async () => {
+            const requiredVersion = await this.getRequiredNode_Version();
+            const installedVersions = await this.getInstalledNode_Versions();
+            this.logDebug('Found versions:', installedVersions);
+            if (installedVersions.includes(requiredVersion))
+                return false;
+            await this.installVersion(requiredVersion);
+            return true;
+        };
+        this.getInstalledNode_Versions = async () => {
+            function extractInstalledVersions(rawOutput) {
+                const cleanedOutput = (0, tools_1.removeAnsiCodes)(rawOutput);
+                const lines = cleanedOutput.split('\n');
+                const filteredVersionLines = lines
+                    .filter(line => !!line && line.match(/v\d+\.\d+\.\d+/) && !line.includes('N/A'));
+                return (0, ts_common_1.filterDuplicates)(filteredVersionLines
+                    .map(line => { var _a; return (_a = line.match(/v(\d+\.\d+\.\d+)/)) === null || _a === void 0 ? void 0 : _a[1]; }));
+            }
+            return extractInstalledVersions((await this.createCommando()
+                .append('nvm ls')
+                .execute()).stdout);
+        };
+        this.uninstall = async () => {
+            this.logDebug('Uninstalling PNPM');
+            const absolutePathToNVM_Home = process.env[this._homeEnvVar];
+            if (!absolutePathToNVM_Home)
+                return;
+            fs.rmSync(absolutePathToNVM_Home, { recursive: true, force: true });
+        };
+        this.installVersion = async (requiredVersion) => {
+            requiredVersion !== null && requiredVersion !== void 0 ? requiredVersion : (requiredVersion = await this.getRequiredNode_Version());
+            this.logDebug(`Installing version: ${requiredVersion}`);
+            return this.createCommando().append(`nvm install ${requiredVersion}`).execute();
+        };
+        this.setMinLevel(ts_common_1.LogLevel.Verbose);
+    }
+    get homeEnvVar() {
+        return this._homeEnvVar;
+    }
+    set homeEnvVar(value) {
+        this._homeEnvVar = value;
+    }
+    get expectedVersion() {
+        return this._expectedVersion;
+    }
+    set expectedVersion(value) {
+        this._expectedVersion = value;
+    }
+    async getVersion() {
+        const commando = cli_1.Commando.create(programming_1.Cli_Programming, basic_1.Cli_Basic);
+        return commando.if('[[ -x "$(command -v nvm)" ]]', (commando) => {
+            commando.cli.append('nvm --version');
+        }).execute();
+    }
+    createInteractiveCommando(...plugins) {
+        return cli_1.CommandoInteractive.create(...plugins).debug()
+            .append('export NVM_DIR="$HOME/.nvm"')
+            .append('[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"  # This loads nvm')
+            .append('[ -s "$NVM_DIR/bash_completion" ] && . "$NVM_DIR/bash_completion"  # This loads nvm bash_completion')
+            .append('nvm use');
+    }
+    createCommando(...plugins) {
+        return cli_1.Commando.create(...plugins)
+            .append('export NVM_DIR="$HOME/.nvm"')
+            .append('[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"  # This loads nvm')
+            .append('[ -s "$NVM_DIR/bash_completion" ] && . "$NVM_DIR/bash_completion"  # This loads nvm bash_completion');
+    }
+}
+exports.Cli_NVM = Cli_NVM;
+exports.NVM = new Cli_NVM();

package/cli/pnpm.d.ts

@@ -0,0 +1,27 @@
+import { Commando } from '../core/cli';
+import { Logger } from '@nu-art/ts-common';
+export declare class Cli_PNPM extends Logger {
+    private _expectedVersion;
+    private _homeEnvVar;
+    constructor();
+    get homeEnvVar(): string;
+    set homeEnvVar(value: string);
+    get expectedVersion(): string;
+    set expectedVersion(value: string);
+    install: (commando?: Commando) => Promise<this | undefined>;
+    isInstalled: () => boolean;
+    installPackages: (commando?: Commando) => Promise<this>;
+    private getVersion;
+    uninstall: () => Promise<void>;
+    /**
+     * Asynchronously creates a workspace file with a list of packages.
+     * Each package is listed under the 'packages:' section in the file.
+     *
+     * @param listOfLibs An array of library names to include in the workspace.
+     * @param pathToWorkspaceFile The filesystem path where the workspace file will be written.
+     * @example
+     * await createWorkspace(['pack1', 'pack2'], './path/to/workspace.yaml');
+     */
+    createWorkspace: (listOfLibs: string[], pathToWorkspaceFile?: string) => Promise<void>;
+}
+export declare const PNPM: Cli_PNPM;

package/cli/pnpm.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PNPM = exports.Cli_PNPM = void 0;
+const programming_1 = require("./programming");
+const basic_1 = require("./basic");
+const cli_1 = require("../core/cli");
+const fs_1 = require("fs");
+const tools_1 = require("../core/tools");
+const ts_common_1 = require("@nu-art/ts-common");
+class Cli_PNPM extends ts_common_1.Logger {
+    constructor() {
+        super();
+        this._expectedVersion = '8.15.5';
+        this._homeEnvVar = 'PNPM_HOME';
+        this.install = async (commando) => {
+            if (this.isInstalled()) {
+                const version = (await this.getVersion()).stdout.trim();
+                if (this._expectedVersion === version)
+                    return;
+                await this.uninstall();
+            }
+            this.logDebug(`installing PNPM version ${this._expectedVersion}`);
+            await (commando !== null && commando !== void 0 ? commando : cli_1.Commando.create())
+                .append(`curl -fsSL "https://get.pnpm.io/install.sh" | env PNPM_VERSION=${this._expectedVersion} sh -`)
+                .execute();
+            return this;
+        };
+        this.isInstalled = () => !!process.env[this._homeEnvVar];
+        this.installPackages = async (commando) => {
+            await (commando !== null && commando !== void 0 ? commando : cli_1.Commando.create())
+                .append(`pnpm install -f --no-frozen-lockfile`)
+                .execute();
+            return this;
+        };
+        this.uninstall = async () => {
+            this.logDebug('Uninstalling PNPM');
+            const absolutePathToPNPM_Home = process.env[this._homeEnvVar];
+            if (!absolutePathToPNPM_Home)
+                return;
+            return fs_1.promises.rm(absolutePathToPNPM_Home, { recursive: true, force: true });
+        };
+        /**
+         * Asynchronously creates a workspace file with a list of packages.
+         * Each package is listed under the 'packages:' section in the file.
+         *
+         * @param listOfLibs An array of library names to include in the workspace.
+         * @param pathToWorkspaceFile The filesystem path where the workspace file will be written.
+         * @example
+         * await createWorkspace(['pack1', 'pack2'], './path/to/workspace.yaml');
+         */
+        this.createWorkspace = async (listOfLibs, pathToWorkspaceFile = (0, tools_1.convertToFullPath)('./pnpm-workspace.yaml')) => {
+            try {
+                let workspace = 'packages:\n';
+                listOfLibs.forEach(lib => {
+                    workspace += `  - '${lib}'\n`;
+                });
+                await fs_1.promises.writeFile(pathToWorkspaceFile, workspace, 'utf8');
+                this.logDebug(`Workspace file created at ${pathToWorkspaceFile}`);
+            }
+            catch (error) {
+                this.logError('Failed to create workspace file:', error);
+            }
+        };
+        this.setMinLevel(ts_common_1.LogLevel.Verbose);
+    }
+    get homeEnvVar() {
+        return this._homeEnvVar;
+    }
+    set homeEnvVar(value) {
+        this._homeEnvVar = value;
+    }
+    get expectedVersion() {
+        return this._expectedVersion;
+    }
+    set expectedVersion(value) {
+        this._expectedVersion = value;
+    }
+    async getVersion() {
+        const commando = cli_1.Commando.create(programming_1.Cli_Programming, basic_1.Cli_Basic);
+        return commando.if('[[ -x "$(command -v pnpm)" ]]', (commando) => {
+            commando.cli.append('pnpm --version');
+        }).execute();
+    }
+}
+exports.Cli_PNPM = Cli_PNPM;
+exports.PNPM = new Cli_PNPM();

package/cli/programming.d.ts

@@ -0,0 +1,34 @@
+import { CliBlock, CliWrapper } from '../core/cli';
+export declare class Cli_Programming extends CliWrapper {
+    /**
+     * Constructs an if-else conditional command structure.
+     * @param {string} condition - The condition for the if statement.
+     * @param {CliBlock} ifBlock - Block of commands to execute if the condition is true.
+     * @param {CliBlock} [elseBlock] - Optional block of commands to execute if the condition is false.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    if(condition: string, ifBlock: CliBlock<this>, elseBlock?: CliBlock<this>): this;
+    /**
+     * Constructs a for loop command structure.
+     * @param {string} varName - The variable name used in the loop.
+     * @param {string | string[]} arrayNameOrValues - The array name or array of values to iterate over.
+     * @param {CliBlock} loop - Block of commands to execute in each iteration of the loop.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    for(varName: string, arrayNameOrValues: string | string[], loop: CliBlock<this>): this;
+    /**
+     * Appends a 'continue' command for loop control.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    continue(): this;
+    /**
+     * Appends a 'break' command for loop control.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    break(): this;
+    /**
+     * Appends a 'return' command for exiting a function or script.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    return(): this;
+}

package/cli/programming.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cli_Programming = void 0;
+const cli_1 = require("../core/cli");
+class Cli_Programming extends cli_1.CliWrapper {
+    /**
+     * Constructs an if-else conditional command structure.
+     * @param {string} condition - The condition for the if statement.
+     * @param {CliBlock} ifBlock - Block of commands to execute if the condition is true.
+     * @param {CliBlock} [elseBlock] - Optional block of commands to execute if the condition is false.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    if(condition, ifBlock, elseBlock) {
+        this.cli.append(`if ${condition}; then`);
+        this.cli.indentIn();
+        ifBlock(this);
+        if (elseBlock) {
+            this.cli.indentOut();
+            this.cli.append('else');
+            this.cli.indentIn();
+            elseBlock(this);
+        }
+        this.cli.indentOut();
+        this.cli.append('fi');
+        this.cli.emptyLine();
+        return this;
+    }
+    /**
+     * Constructs a for loop command structure.
+     * @param {string} varName - The variable name used in the loop.
+     * @param {string | string[]} arrayNameOrValues - The array name or array of values to iterate over.
+     * @param {CliBlock} loop - Block of commands to execute in each iteration of the loop.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    for(varName, arrayNameOrValues, loop) {
+        if (typeof arrayNameOrValues === 'string') {
+            this.cli.append(`for ${varName} in "\${${arrayNameOrValues}[@]}"; do`);
+        }
+        else {
+            const values = arrayNameOrValues.map(value => `"${value}"`).join(' ');
+            this.cli.append(`for ${varName} in ${values}; do`);
+        }
+        this.cli.indentIn();
+        loop(this);
+        this.cli.indentOut();
+        this.cli.append('done');
+        this.cli.emptyLine();
+        return this;
+    }
+    /**
+     * Appends a 'continue' command for loop control.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    continue() {
+        this.cli.append('continue');
+        return this;
+    }
+    /**
+     * Appends a 'break' command for loop control.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    break() {
+        this.cli.append('break');
+        return this;
+    }
+    /**
+     * Appends a 'return' command for exiting a function or script.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    return() {
+        this.cli.append('return');
+        return this;
+    }
+}
+exports.Cli_Programming = Cli_Programming;

package/core/CliError.d.ts

@@ -0,0 +1,6 @@
+export declare class CliError extends Error {
+    stdout: string;
+    stderr: string;
+    cause?: Error;
+    constructor(message: string, stdout: string, stderr: string, cause?: Error);
+}

package/core/CliError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliError = void 0;
+class CliError extends Error {
+    constructor(message, stdout, stderr, cause) {
+        super(message);
+        this.stdout = stdout;
+        this.stderr = stderr;
+        this.cause = cause;
+    }
+}
+exports.CliError = CliError;

package/core/class-merger.d.ts

@@ -0,0 +1,5 @@
+type Constructor<T = {}> = new (...args: any[]) => T;
+export type MergeTypes<T extends Constructor<any>[]> = T extends [a: Constructor<infer A>, ...rest: infer R] ? R extends Constructor<any>[] ? A & MergeTypes<R> : {} : {};
+export declare function MergeClass<T extends Constructor<any>[]>(...plugins: T): Constructor<MergeTypes<T>>;
+export declare function CreateMergedInstance<T extends Constructor<any>[]>(...plugins: T): MergeTypes<T>;
+export {};

package/core/class-merger.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateMergedInstance = exports.MergeClass = void 0;
+function MergeClass(...plugins) {
+    class SuperClass {
+        constructor(...args) {
+            plugins.forEach(plugin => {
+                Object.getOwnPropertyNames(plugin.prototype).forEach(name => {
+                    const prop = Object.getOwnPropertyDescriptor(plugin.prototype, name);
+                    if (prop) {
+                        Object.defineProperty(this, name, prop);
+                    }
+                });
+            });
+        }
+    }
+    return SuperClass;
+}
+exports.MergeClass = MergeClass;
+function CreateMergedInstance(...plugins) {
+    const SuperClass = MergeClass(...plugins);
+    return new SuperClass();
+}
+exports.CreateMergedInstance = CreateMergedInstance;

package/core/cli.d.ts

@@ -0,0 +1,98 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ExecOptions } from 'child_process';
+import { Constructor, Logger } from '@nu-art/ts-common';
+export type CliBlock<Cli extends CliWrapper> = (cli: Cli) => void;
+export type CliOptions = ExecOptions & {
+    encoding: BufferEncoding | string | null;
+};
+/**
+ * Type definition for options used in Cli class.
+ */
+type Options = {
+    newlineDelimiter: string;
+    indentation: number;
+};
+export declare class BaseCLI extends Logger {
+    protected commands: string[];
+    private indentation;
+    protected _debug: boolean;
+    protected option: Options;
+    /**
+     * Constructs a CLI instance with given options.
+     * @param {Options} options - Configuration options for the CLI instance.
+     */
+    constructor(options?: Partial<Options>);
+    protected getIndentation: () => string;
+    readonly indentIn: () => void;
+    readonly indentOut: () => void;
+    debug(debug?: boolean): boolean;
+    /**
+     * Appends a command or a Cli instance to the command list with proper indentation.
+     * @param {string} command - The command or Cli instance to append.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    readonly append: (command: string) => this;
+}
+export declare class CliInteractive extends BaseCLI {
+    private shell;
+    constructor();
+    execute: () => Promise<void>;
+    endInteractive: () => void;
+}
+export declare class Cli extends BaseCLI {
+    private cliOptions;
+    /**
+     * Executes the accumulated commands in the command list.
+     * @returns {Promise<string>} A promise that resolves with the standard output of the executed command.
+     */
+    execute: () => Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+    /**
+     * Appends an empty line to the script for readability.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    emptyLine(): this;
+    setShell(shell: string): void;
+    setOptions(options: Partial<CliOptions>): void;
+}
+export declare class CliWrapper {
+    cli: Cli;
+}
+export declare class Commando {
+    cli: Cli;
+    static create<T extends Constructor<CliWrapper>[]>(...plugins: T): Commando & import("./class-merger").MergeTypes<T>;
+    setShell: (shell: string) => this;
+    setOptions: (options: ExecOptions) => this;
+    debug: (debug?: boolean) => this;
+    append: (command: string) => this;
+    execute: () => Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+    /**
+     * Executes a given file.
+     * @param {string} filePath - The path to the file to execute.
+     * @param {string} [interpreter] - Optional. The interpreter to use for executing the file (e.g., "python", "bash").
+     *                                 If not provided, the file is executed directly.
+     *
+     * @returns {Cli} - The script execution output.
+     */
+    executeFile: (filePath: string, interpreter?: string) => Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+    executeRemoteFile: (pathToFile: string, interpreter: string) => Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+    private constructor();
+}
+export declare class CommandoInteractive {
+    cli: CliInteractive;
+    static create<T extends Constructor<CliWrapper>[]>(...plugins: T): CommandoInteractive & Commando & import("./class-merger").MergeTypes<T>;
+    close: () => this;
+}
+export {};

package/core/cli.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandoInteractive = exports.Commando = exports.CliWrapper = exports.Cli = exports.CliInteractive = exports.BaseCLI = void 0;
+const child_process_1 = require("child_process");
+const class_merger_1 = require("./class-merger");
+const CliError_1 = require("./CliError");
+const ts_common_1 = require("@nu-art/ts-common");
+const node_child_process_1 = require("node:child_process");
+/**
+ * Default options for Cli class instances.
+ */
+const defaultOptions = {
+    newlineDelimiter: '\n',
+    indentation: 2,
+};
+class BaseCLI extends ts_common_1.Logger {
+    /**
+     * Constructs a CLI instance with given options.
+     * @param {Options} options - Configuration options for the CLI instance.
+     */
+    constructor(options = defaultOptions) {
+        super();
+        this.commands = [];
+        this.indentation = 0;
+        this._debug = false;
+        this.getIndentation = () => {
+            return ' '.repeat(this.option.indentation * this.indentation);
+        };
+        this.indentIn = () => {
+            this.indentation++;
+        };
+        this.indentOut = () => {
+            this.indentation++;
+        };
+        /**
+         * Appends a command or a Cli instance to the command list with proper indentation.
+         * @param {string} command - The command or Cli instance to append.
+         * @returns {this} - The Cli instance for method chaining.
+         */
+        this.append = (command) => {
+            this.commands.push(`${this.getIndentation()}${command}`);
+            return this;
+        };
+        this.setMinLevel(ts_common_1.LogLevel.Verbose);
+        this.option = options;
+    }
+    debug(debug) {
+        this._debug = debug !== null && debug !== void 0 ? debug : !this._debug;
+        return this._debug;
+    }
+}
+exports.BaseCLI = BaseCLI;
+class CliInteractive extends BaseCLI {
+    constructor() {
+        super();
+        this.execute = async () => {
+            const command = this.commands.join(this.option.newlineDelimiter);
+            if (this._debug)
+                this.logDebug(`executing: `, `"""\n${command}\n"""`);
+            this.shell.stdin.write(command + this.option.newlineDelimiter, 'utf-8', (err) => {
+                console.log('GOT HERE');
+                if (err)
+                    console.error(err);
+            });
+            this.commands = [];
+        };
+        this.endInteractive = () => {
+            this.shell.stdin.end();
+        };
+        this.shell = (0, node_child_process_1.spawn)('/bin/bash', {});
+        // Handle shell output (stdout)
+        const printer = (data) => {
+            const message = data.toString().trim();
+            if (!message.length)
+                return;
+            console.log(message);
+        };
+        this.shell.stdout.on('data', printer);
+        this.shell.stderr.on('data', printer);
+        // Handle shell errors (stderr)
+        this.shell.on('data', printer);
+        // Handle shell exit
+        this.shell.on('close', (code) => {
+            console.log(`child process exited with code ${code}`);
+        });
+    }
+}
+exports.CliInteractive = CliInteractive;
+class Cli extends BaseCLI {
+    constructor() {
+        super(...arguments);
+        this.cliOptions = { shell: '/bin/bash' };
+        /**
+         * Executes the accumulated commands in the command list.
+         * @returns {Promise<string>} A promise that resolves with the standard output of the executed command.
+         */
+        this.execute = async () => {
+            const command = this.commands.join(this.option.newlineDelimiter);
+            if (this._debug)
+                this.logDebug(`executing: `, `"""\n${command}\n"""`);
+            return new Promise((resolve, reject) => {
+                (0, child_process_1.exec)(command, this.cliOptions, (error, stdout, stderr) => {
+                    this.commands = [];
+                    if (error) {
+                        reject(new CliError_1.CliError(`executing:\n${command}\n`, stdout, stderr, error));
+                    }
+                    if (stderr)
+                        reject(stderr);
+                    if (stdout) {
+                        console.log(stdout);
+                        this.logVerbose(stdout);
+                    }
+                    if (stderr)
+                        this.logVerboseBold(stderr);
+                    resolve({ stdout, stderr });
+                });
+            });
+        };
+    }
+    /**
+     * Appends an empty line to the script for readability.
+     * @returns {this} - The Cli instance for method chaining.
+     */
+    emptyLine() {
+        this.append('');
+        return this;
+    }
+    setShell(shell) {
+        (this.cliOptions || (this.cliOptions = {})).shell = shell;
+    }
+    setOptions(options) {
+        this.cliOptions = options;
+    }
+}
+exports.Cli = Cli;
+class CliWrapper {
+}
+exports.CliWrapper = CliWrapper;
+class Commando {
+    static create(...plugins) {
+        const _commando = (0, class_merger_1.CreateMergedInstance)(...plugins);
+        const commando = _commando;
+        const cli = new Cli();
+        cli.setMinLevel(ts_common_1.LogLevel.Verbose);
+        commando.cli = cli;
+        commando.execute = () => commando.cli.execute();
+        commando.debug = (debug) => {
+            commando.cli.debug(debug);
+            return commando;
+        };
+        commando.setOptions = (options) => {
+            commando.cli.setOptions(options);
+            return commando;
+        };
+        commando.setShell = (shell) => {
+            commando.cli.setShell(shell);
+            return commando;
+        };
+        commando.executeFile = (filePath, interpreter) => {
+            let command = filePath;
+            // If an interpreter is provided, prefix the command with it.
+            if (interpreter) {
+                command = `${interpreter} ${filePath}`;
+            }
+            return new Cli().append(command).execute();
+        };
+        commando.executeRemoteFile = (pathToFile, interpreter) => {
+            return new Cli().append(`curl -o- "${pathToFile}" | ${interpreter}`).execute();
+        };
+        commando.append = (command) => {
+            commando.cli.append(command);
+            return commando;
+        };
+        return commando;
+    }
+    constructor() {
+        this.setShell = (shell) => this;
+        this.setOptions = (options) => this;
+        this.debug = (debug) => this;
+        this.append = (command) => this;
+        this.execute = async () => ({ stdout: '', stderr: '', }); // placeholder
+        /**
+         * Executes a given file.
+         * @param {string} filePath - The path to the file to execute.
+         * @param {string} [interpreter] - Optional. The interpreter to use for executing the file (e.g., "python", "bash").
+         *                                 If not provided, the file is executed directly.
+         *
+         * @returns {Cli} - The script execution output.
+         */
+        this.executeFile = async (filePath, interpreter) => ({ stdout: '', stderr: '', });
+        this.executeRemoteFile = async (pathToFile, interpreter) => ({ stdout: '', stderr: '', });
+    }
+}
+exports.Commando = Commando;
+class CommandoInteractive {
+    constructor() {
+        this.close = () => this;
+    }
+    static create(...plugins) {
+        const _commando = Commando.create(...plugins);
+        const commando = _commando;
+        const cli = new CliInteractive();
+        cli.setMinLevel(ts_common_1.LogLevel.Verbose);
+        commando.cli = cli;
+        commando.close = () => {
+            return commando;
+        };
+        return commando;
+    }
+}
+exports.CommandoInteractive = CommandoInteractive;

package/core/tools.d.ts

@@ -0,0 +1,2 @@
+export declare function removeAnsiCodes(text: string): string;
+export declare function convertToFullPath(pathToFile: string, assetParentPath?: string): string;

package/core/tools.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToFullPath = exports.removeAnsiCodes = void 0;
+const path = require("path");
+function removeAnsiCodes(text) {
+    // This regular expression matches the escape codes and removes them
+    return text.replace(/\x1B\[\d+;?\d*m/g, '');
+}
+exports.removeAnsiCodes = removeAnsiCodes;
+function convertToFullPath(pathToFile, assetParentPath = process.cwd()) {
+    if (!pathToFile)
+        throw new Error('Path not provided');
+    if (pathToFile === '')
+        throw new Error('Empty path not allowed');
+    while (pathToFile.startsWith('/'))
+        pathToFile = pathToFile.substring(1);
+    const absolutePath = path.resolve(assetParentPath, pathToFile);
+    if (!absolutePath.startsWith(assetParentPath))
+        throw new Error(`Found path: '${absolutePath}' which is out of the scope of the assert directory: '${assetParentPath}'`);
+    return absolutePath;
+}
+exports.convertToFullPath = convertToFullPath;

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@nu-art/commando",
+  "version": "0.203.117",
+  "description": "",
+  "keywords": [
+    "TacB0sS",
+    "infra",
+    "nu-art",
+    "commando"
+  ],
+  "homepage": "https://github.com/nu-art-js/thunderstorm",
+  "bugs": {
+    "url": "https://github.com/nu-art-js/thunderstorm/issues"
+  },
+  "publishConfig": {
+    "directory": "dist",
+    "linkDirectory": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com:nu-art-js/thunderstorm.git"
+  },
+  "license": "Apache-2.0",
+  "author": "TacB0sS",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "**/*"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@nu-art/ts-common": "0.203.117"
+  },
+  "devDependencies": {
+    "@types/node": "^18.0.0"
+  }
+}

package/test-scripts/test-params.d.ts

@@ -0,0 +1 @@
+export {};

package/test-scripts/test-params.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_params_1 = require("../cli/cli-params");
+const testParam1 = {
+    keys: ['--test1', '-t1'],
+    keyName: 'test1',
+    type: 'string',
+    description: '',
+    defaultValue: 'psulet'
+};
+const testParam2 = {
+    keys: ['--test2'],
+    keyName: 'test2',
+    type: 'string[]',
+    description: ''
+};
+const testParam3 = {
+    keys: ['--test3'],
+    keyName: 'test3',
+    type: 'number',
+    description: ''
+};
+const testParam4 = {
+    keys: ['--test4'],
+    keyName: 'test4',
+    type: 'number[]',
+    description: ''
+};
+const testParam5 = {
+    keys: ['--test5'],
+    keyName: 'test5',
+    type: 'boolean',
+    description: ''
+};
+const testParam6 = {
+    keys: ['--test6'],
+    keyName: 'test6',
+    type: 'boolean[]',
+    description: ''
+};
+const params = [testParam1, testParam2, testParam3, testParam4, testParam5, testParam6];
+const MyAppParamResolver = new cli_params_1.CLIParams_Resolver(params);
+console.log(MyAppParamResolver.resolveParamValue());