@nu-art/commando 0.204.86 → 0.204.88

package/cli-params/consts.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultProcessorsMapper = exports.DefaultProcessor_Number = exports.DefaultProcessor_String = exports.DefaultProcessor_Boolean = void 0;
+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;
+exports.DefaultProcessorsMapper = {
+    string: exports.DefaultProcessor_String,
+    boolean: exports.DefaultProcessor_Boolean,
+    number: exports.DefaultProcessor_Number,
+};

package/cli-params/types.d.ts

@@ -0,0 +1,27 @@
+import { Primitive, TypeOfTypeAsString } from '@nu-art/ts-common';
+export type CliParams<T extends BaseCliParam<string, any>[]> = {
+    [K in T[number]['keyName']]: NonNullable<Extract<T[number], {
+        keyName: K;
+    }>['defaultValue']>;
+};
+export type DependencyParam<T extends Primitive | Primitive[]> = {
+    param: BaseCliParam<string, T>;
+    value: T;
+};
+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;
+    dependencies?: DependencyParam<any>[];
+};
+export type CliParam<K extends string, V extends Primitive | Primitive[]> = BaseCliParam<K, V> & {
+    name: string;
+    process: (value?: string, defaultValue?: V) => V;
+};

package/cli-params/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/commando",
-  "version": "0.204.86",
+  "version": "0.204.88",
   "description": "",
   "keywords": [
     "TacB0sS",

package/shell/core/BaseCommando.d.ts

@@ -0,0 +1,54 @@
+import { Constructor } from '@nu-art/ts-common';
+import { CommandBuilder } from './CommandBuilder';
+export declare class BaseCommando {
+    protected readonly builder: CommandBuilder;
+    protected _debug: boolean;
+    /**
+     * Creates a new instance of BaseCommando merged with the provided plugins.
+     * @param {Constructor<any>[]} plugins - The plugins to merge with BaseCommando.
+     * @returns The Super type merged of BaseCommando and all the plugins provided new instance of BaseCommando merged with the plugins.
+     */
+    static _create<T extends Constructor<any>[]>(...plugins: T): import("./class-merger").MergeTypes<[typeof BaseCommando, ...T]> & BaseCommando;
+    /**
+     * Constructs a BaseCommando instance.
+     */
+    constructor();
+    /**
+     * Toggles or sets the debug mode.
+     * @param {boolean} [debug] - If provided, sets the debug mode to this value. Otherwise, toggles the current debug mode.
+     * @returns {boolean} - The current state of debug mode.
+     */
+    debug(debug?: boolean): this;
+    /**
+     * Appends a command to the command list.
+     * @param {string} command - The command to append.
+     * @returns {this} - The BaseCommando instance for method chaining.
+     */
+    append(command: string): this;
+    /**
+     * Increases the current indentation level by one.
+     * @returns {this} - The BaseCommando instance for method chaining.
+     */
+    indentIn(): this;
+    /**
+     * Decreases the current indentation level by one.
+     * @returns {this} - The BaseCommando instance for method chaining.
+     */
+    indentOut(): this;
+    /**
+     * Appends an empty line to the script for readability.
+     * @returns {this} - The BaseCommando instance for method chaining.
+     */
+    emptyLine(): this;
+    /**
+     * Executes the commands. Must be overridden in a subclass.
+     * @throws {ImplementationMissingException} - Always throws this exception.
+     */
+    execute(): Promise<void>;
+    /**
+     * Executes the commands with a callback. Must be overridden in a subclass.
+     * @param {Function} callback - A callback function to handle the command output.
+     * @throws {ImplementationMissingException} - Always throws this exception.
+     */
+    execute<T>(callback: (stdout: string, stderr: string, exitCode: number) => T): Promise<T>;
+}

package/shell/core/BaseCommando.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCommando = void 0;
+const ts_common_1 = require("@nu-art/ts-common");
+const CommandBuilder_1 = require("./CommandBuilder");
+const class_merger_1 = require("./class-merger");
+class BaseCommando {
+    /**
+     * Creates a new instance of BaseCommando merged with the provided plugins.
+     * @param {Constructor<any>[]} plugins - The plugins to merge with BaseCommando.
+     * @returns The Super type merged of BaseCommando and all the plugins provided new instance of BaseCommando merged with the plugins.
+     */
+    static _create(...plugins) {
+        const _commando = (0, class_merger_1.CreateMergedInstance)(BaseCommando, ...plugins);
+        const commando = _commando;
+        // @ts-ignore
+        commando.builder = new CommandBuilder_1.CommandBuilder();
+        return commando;
+    }
+    /**
+     * Constructs a BaseCommando instance.
+     */
+    constructor() {
+        this._debug = false;
+        this.builder = new CommandBuilder_1.CommandBuilder();
+    }
+    /**
+     * Toggles or sets the debug mode.
+     * @param {boolean} [debug] - If provided, sets the debug mode to this value. Otherwise, toggles the current debug mode.
+     * @returns {boolean} - The current state of debug mode.
+     */
+    debug(debug) {
+        this._debug = debug !== null && debug !== void 0 ? debug : !this._debug;
+        return this;
+    }
+    /**
+     * Appends a command to the command list.
+     * @param {string} command - The command to append.
+     * @returns {this} - The BaseCommando instance for method chaining.
+     */
+    append(command) {
+        this.builder.append(command);
+        return this;
+    }
+    /**
+     * Increases the current indentation level by one.
+     * @returns {this} - The BaseCommando instance for method chaining.
+     */
+    indentIn() {
+        this.builder.indentIn();
+        return this;
+    }
+    /**
+     * Decreases the current indentation level by one.
+     * @returns {this} - The BaseCommando instance for method chaining.
+     */
+    indentOut() {
+        this.builder.indentOut();
+        return this;
+    }
+    /**
+     * Appends an empty line to the script for readability.
+     * @returns {this} - The BaseCommando instance for method chaining.
+     */
+    emptyLine() {
+        this.builder.emptyLine();
+        return this;
+    }
+    async execute(callback) {
+        throw new ts_common_1.ImplementationMissingException('need to override this method in your class');
+    }
+}
+exports.BaseCommando = BaseCommando;

package/shell/core/CliError.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { CustomException } from '@nu-art/ts-common';
+import { ExecException } from 'child_process';
+export declare class CliError extends CustomException {
+    stdout: string;
+    stderr: string;
+    cause: ExecException;
+    constructor(message: string, stdout: string, stderr: string, cause: ExecException);
+}
+export declare class CommandoException extends CustomException {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    constructor(message: string, stdout: string, stderr: string, exitCode: number);
+}

package/shell/core/CliError.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandoException = exports.CliError = void 0;
+const ts_common_1 = require("@nu-art/ts-common");
+class CliError extends ts_common_1.CustomException {
+    constructor(message, stdout, stderr, cause) {
+        super(CliError, message, cause);
+        this.stdout = stdout;
+        this.stderr = stderr;
+        this.cause = cause;
+    }
+}
+exports.CliError = CliError;
+class CommandoException extends ts_common_1.CustomException {
+    constructor(message, stdout, stderr, exitCode) {
+        super(CliError, message);
+        this.stdout = stdout;
+        this.stderr = stderr;
+        this.exitCode = exitCode;
+    }
+}
+exports.CommandoException = CommandoException;

package/shell/core/CommandBuilder.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Type definition for options used in the CommandBuilder class.
+ */
+type Options = {
+    newlineDelimiter: string;
+    indentation: number;
+};
+export declare class CommandBuilder {
+    commands: string[];
+    private indentation;
+    private option;
+    /**
+     * Constructs a CommandBuilder instance with given options.
+     * @param {Partial<Options>} [options=defaultOptions] - Configuration options for the CommandBuilder instance.
+     */
+    constructor(options?: Partial<Options>);
+    /**
+     * Generates a string of spaces for indentation based on the current indentation level.
+     * @returns {string} - A string containing spaces for the current indentation level.
+     */
+    protected getIndentation: () => string;
+    /**
+     * Increases the current indentation level by one.
+     */
+    readonly indentIn: () => void;
+    /**
+     * Decreases the current indentation level by one.
+     */
+    readonly indentOut: () => void;
+    /**
+     * Appends an empty line to the command list for readability.
+     * @returns {this} - The CommandBuilder instance for method chaining.
+     */
+    emptyLine(): this;
+    /**
+     * Appends a command to the command list with proper indentation.
+     * @param {string} command - The command to append.
+     * @returns {this} - The CommandBuilder instance for method chaining.
+     */
+    readonly append: (command: string) => this;
+    /**
+     * Retrieves the full command list as a single string.
+     * @returns {string} - The full command list.
+     */
+    getCommand(): string;
+    /**
+     * Resets the command list and returns the previously accumulated commands.
+     * @returns {string} - The previously accumulated commands.
+     */
+    reset(): string;
+}
+export {};

package/shell/core/CommandBuilder.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandBuilder = void 0;
+/**
+ * Default options for CommandBuilder class instances.
+ */
+const defaultOptions = {
+    newlineDelimiter: '\n ',
+    indentation: 2,
+};
+class CommandBuilder {
+    /**
+     * Constructs a CommandBuilder instance with given options.
+     * @param {Partial<Options>} [options=defaultOptions] - Configuration options for the CommandBuilder instance.
+     */
+    constructor(options = defaultOptions) {
+        this.commands = [];
+        this.indentation = 0;
+        this.option = defaultOptions;
+        /**
+         * Generates a string of spaces for indentation based on the current indentation level.
+         * @returns {string} - A string containing spaces for the current indentation level.
+         */
+        this.getIndentation = () => {
+            return ' '.repeat(this.option.indentation * this.indentation);
+        };
+        /**
+         * Increases the current indentation level by one.
+         */
+        this.indentIn = () => {
+            this.indentation++;
+        };
+        /**
+         * Decreases the current indentation level by one.
+         */
+        this.indentOut = () => {
+            this.indentation--;
+        };
+        /**
+         * Appends a command to the command list with proper indentation.
+         * @param {string} command - The command to append.
+         * @returns {this} - The CommandBuilder instance for method chaining.
+         */
+        this.append = (command) => {
+            const commands = command.split(this.option.newlineDelimiter);
+            for (const _command of commands) {
+                this.commands.push(`${this.getIndentation()}${_command.trim()}`);
+            }
+            return this;
+        };
+        this.option = options;
+    }
+    /**
+     * Appends an empty line to the command list for readability.
+     * @returns {this} - The CommandBuilder instance for method chaining.
+     */
+    emptyLine() {
+        this.append('');
+        return this;
+    }
+    /**
+     * Retrieves the full command list as a single string.
+     * @returns {string} - The full command list.
+     */
+    getCommand() {
+        return this.commands.join(this.option.newlineDelimiter);
+    }
+    /**
+     * Resets the command list and returns the previously accumulated commands.
+     * @returns {string} - The previously accumulated commands.
+     */
+    reset() {
+        const command = this.getCommand();
+        this.commands.length = 0;
+        return command;
+    }
+}
+exports.CommandBuilder = CommandBuilder;

package/shell/core/class-merger.d.ts

@@ -0,0 +1,20 @@
+import { Constructor } from '@nu-art/ts-common';
+/**
+ * Type utility to recursively merge the types of constructors in an array.
+ * @template T - An array of constructors.
+ */
+export type MergeTypes<T extends Constructor<any>[]> = T extends [a: Constructor<infer A>, ...rest: infer R] ? R extends Constructor<any>[] ? A & MergeTypes<R> : {} : {};
+/**
+ * Function to merge multiple classes into a single class.
+ * @template T - An array of constructors.
+ * @param {...T} plugins - The constructors to merge.
+ * @returns {Constructor<MergeTypes<T>>} - A new constructor that merges all the provided constructors.
+ */
+export declare function MergeClass<T extends Constructor<any>[]>(...plugins: T): Constructor<MergeTypes<T>>;
+/**
+ * Function to create an instance of a class that merges multiple classes.
+ * @template T - An array of constructors.
+ * @param {...T} plugins - The constructors to merge.
+ * @returns {MergeTypes<T>} - An instance of the merged class.
+ */
+export declare function CreateMergedInstance<T extends Constructor<any>[]>(...plugins: T): MergeTypes<T>;

package/{core → shell/core}/class-merger.js

@@ -1,8 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateMergedInstance = exports.MergeClass = void 0;
+/**
+ * Function to merge multiple classes into a single class.
+ * @template T - An array of constructors.
+ * @param {...T} plugins - The constructors to merge.
+ * @returns {Constructor<MergeTypes<T>>} - A new constructor that merges all the provided constructors.
+ */
 function MergeClass(...plugins) {
     class SuperClass {
+        /**
+         * Constructs an instance of SuperClass, merging properties from all plugins.
+         * @param {...any[]} args - The arguments to pass to the constructors.
+         */
         constructor(...args) {
             plugins.forEach(plugin => {
                 Object.getOwnPropertyNames(plugin.prototype).forEach(name => {
@@ -17,6 +27,12 @@ function MergeClass(...plugins) {
     return SuperClass;
 }
 exports.MergeClass = MergeClass;
+/**
+ * Function to create an instance of a class that merges multiple classes.
+ * @template T - An array of constructors.
+ * @param {...T} plugins - The constructors to merge.
+ * @returns {MergeTypes<T>} - An instance of the merged class.
+ */
 function CreateMergedInstance(...plugins) {
     const SuperClass = MergeClass(...plugins);
     return new SuperClass();

package/shell/index.d.ts

@@ -0,0 +1,2 @@
+export * from './interactive/CommandoInteractive';
+export * from './simple/Commando';

package/shell/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./interactive/CommandoInteractive"), exports);
+__exportStar(require("./simple/Commando"), exports);

package/shell/interactive/CommandoInteractive.d.ts

@@ -0,0 +1,83 @@
+/// <reference types="node" />
+import { Constructor } from '@nu-art/ts-common';
+import { LogTypes } from '../types';
+import { BaseCommando } from '../core/BaseCommando';
+export declare class CommandoInteractive extends BaseCommando {
+    private shell;
+    /**
+     * Creates a new instance of CommandoInteractive merged with the provided plugins.
+     * @param {Constructor<any>[]} plugins - The plugins to merge with CommandoInteractive.
+     * @returns {CommandoInteractive} - The new instance of CommandoInteractive merged with the plugins.
+     */
+    static create<T extends Constructor<any>[]>(...plugins: T): import("../core/class-merger").MergeTypes<[typeof BaseCommando, typeof CommandoInteractive, ...T]> & BaseCommando & CommandoInteractive;
+    /**
+     * Constructs a CommandoInteractive instance.
+     */
+    constructor();
+    /**
+     * Toggles or sets the debug mode.
+     * @param {boolean} [debug] - If provided, sets the debug mode to this value. Otherwise, toggles the current debug mode.
+     * @returns {boolean} - The current state of debug mode.
+     */
+    debug(debug?: boolean): this;
+    /**
+     * Sets the UID for the shell.
+     * @param {string} uid - The UID to set.
+     * @returns {this} - The CommandoInteractive instance for method chaining.
+     */
+    setUID(uid: string): this;
+    /**
+     * Closes the shell, optionally with a callback function.
+     * @returns {this} - The CommandoInteractive instance for method chaining.
+     */
+    close(): Promise<void>;
+    /**
+     * Kills the shell process with a given signal.
+     * @param {NodeJS.Signals | number} [signal] - The signal to send to the process.
+     * @returns {boolean} - Whether the kill signal was successfully sent.
+     */
+    kill(signal?: NodeJS.Signals | number): boolean | undefined;
+    /**
+     * Gracefully kills a process by its PID.
+     * @param {number} [pid] - The PID of the process to kill.
+     */
+    gracefullyKill(pid?: number): Promise<void>;
+    /**
+     * Waits for a log entry that matches a specified pattern, then executes a callback.
+     * @param {string | RegExp} filter - The pattern to match in log entries.
+     * @param {(match: RegExpMatchArray) => any} callback - The callback to execute when a match is found.
+     */
+    onLog(filter: string | RegExp, callback: (match: RegExpMatchArray) => any): void;
+    /**
+     * Executes commands asynchronously and listens for the PID.
+     *
+     * @param {Function} pidListener - A listener function to handle the PID.
+     * @param {Function} [callback] - A callback function to handle the command output.
+     * @returns {Promise<T>} - The result of the callback function.
+     */
+    executeAsync<T>(pidListener: (pid: number) => void, callback?: (stdout: string, stderr: string, exitCode: number) => T): Promise<T>;
+    /**
+     * Executes commands and processes logs to extract exit code.
+     * @param {Function} [callback] - A callback function to handle the command output.
+     * @returns {Promise<T>} - The result of the callback function.
+     */
+    execute<T>(callback?: (stdout: string, stderr: string, exitCode: number) => T): Promise<T>;
+    /**
+     * Adds a log processor to the shell.
+     * @param {Function} processor - The log processor function to add.
+     * @returns {this} - The CommandoInteractive instance for method chaining.
+     */
+    addLogProcessor(processor: (log: string, std: LogTypes) => boolean): this;
+    /**
+     * Removes a log processor from the shell.
+     * @param {Function} processor - The log processor function to remove.
+     * @returns {this} - The CommandoInteractive instance for method chaining.
+     */
+    removeLogProcessor(processor: (log: string, std: LogTypes) => boolean): this;
+    /**
+     * Appends a command to the command list.
+     * @param {string} command - The command to append.
+     * @returns {this} - The CommandoInteractive instance for method chaining.
+     */
+    append(command: string): this;
+}