@decaf-ts/utils 0.1.6

package/lib/esm/input/input.js

@@ -0,0 +1,570 @@
+import prompts from "prompts";
+import { parseArgs } from "util";
+import { Logging } from "../output/logging";
+/**
+ * @description Represents a user input prompt with various configuration options.
+ * @summary This class provides a flexible interface for creating and managing user input prompts.
+ * It implements the PromptObject interface from the 'prompts' library and offers methods to set
+ * various properties of the prompt. The class also includes static methods for common input scenarios
+ * and argument parsing.
+ *
+ * @template R - The type of the prompt name, extending string.
+ *
+ * @param name - The name of the prompt, used as the key in the returned answers object.
+ *
+ * @class
+ */
+export class UserInput {
+    static { this.logger = Logging.for(UserInput); }
+    /**
+     * @description Creates a new UserInput instance.
+     * @summary Initializes a new UserInput object with the given name.
+     *
+     * @param name - The name of the prompt.
+     */
+    constructor(name) {
+        /**
+         * @description The type of the prompt.
+         * @summary Determines the input method (e.g., text, number, confirm).
+         */
+        this.type = "text";
+        this.name = name;
+    }
+    /**
+     * @description Sets the type of the prompt.
+     * @summary Configures the input method for the prompt.
+     *
+     * @param type - The type of the prompt.
+     * @returns This UserInput instance for method chaining.
+     */
+    setType(type) {
+        UserInput.logger.verbose(`Setting type to: ${type}`);
+        this.type = type;
+        return this;
+    }
+    /**
+     * @description Sets the message of the prompt.
+     * @summary Configures the question or instruction presented to the user.
+     *
+     * @param value - The message to be displayed.
+     * @returns This UserInput instance for method chaining.
+     */
+    setMessage(value) {
+        UserInput.logger.verbose(`Setting message to: ${value}`);
+        this.message = value;
+        return this;
+    }
+    /**
+     * @description Sets the initial value of the prompt.
+     * @summary Configures the default value presented to the user.
+     *
+     * @param value - The initial value.
+     * @returns This UserInput instance for method chaining.
+     */
+    setInitial(value) {
+        UserInput.logger.verbose(`Setting initial value to: ${value}`);
+        this.initial = value;
+        return this;
+    }
+    /**
+     * @description Sets the style of the prompt.
+     * @summary Configures the visual style of the prompt.
+     *
+     * @param value - The style to be applied.
+     * @returns This UserInput instance for method chaining.
+     */
+    setStyle(value) {
+        UserInput.logger.verbose(`Setting style to: ${value}`);
+        this.style = value;
+        return this;
+    }
+    /**
+     * @description Sets the format function of the prompt.
+     * @summary Configures a function to format the user's input before it's returned.
+     *
+     * @param value - The format function.
+     * @returns This UserInput instance for method chaining.
+     */
+    setFormat(value) {
+        UserInput.logger.verbose(`Setting format function`);
+        this.format = value;
+        return this;
+    }
+    /**
+     * @description Sets the validation function of the prompt.
+     * @summary Configures a function to validate the user's input.
+     *
+     * @param value - The validation function.
+     * @returns This UserInput instance for method chaining.
+     */
+    setValidate(value) {
+        UserInput.logger.verbose(`Setting validate function`);
+        this.validate = value;
+        return this;
+    }
+    /**
+     * @description Sets the onState callback of the prompt.
+     * @summary Configures a function to be called when the state of the prompt changes.
+     *
+     * @param value - The onState callback function.
+     * @returns This UserInput instance for method chaining.
+     */
+    setOnState(value) {
+        UserInput.logger.verbose(`Setting onState callback`);
+        this.onState = value;
+        return this;
+    }
+    /**
+     * @description Sets the onRender callback of the prompt.
+     * @summary Configures a function to be called when the prompt is rendered.
+     *
+     * @param value - The onRender callback function.
+     * @returns This UserInput instance for method chaining.
+     */
+    setOnRender(value) {
+        UserInput.logger.verbose(`Setting onRender callback`);
+        this.onRender = value;
+        return this;
+    }
+    /**
+     * @description Sets the minimum value for number inputs.
+     * @summary Configures the lowest number the user can input.
+     *
+     * @param value - The minimum value.
+     * @returns This UserInput instance for method chaining.
+     */
+    setMin(value) {
+        UserInput.logger.verbose(`Setting min value to: ${value}`);
+        this.min = value;
+        return this;
+    }
+    /**
+     * @description Sets the maximum value for number inputs.
+     * @summary Configures the highest number the user can input.
+     *
+     * @param value - The maximum value.
+     * @returns This UserInput instance for method chaining.
+     */
+    setMax(value) {
+        UserInput.logger.verbose(`Setting max value to: ${value}`);
+        this.max = value;
+        return this;
+    }
+    /**
+     * @description Sets whether to allow float values for number inputs.
+     * @summary Configures whether decimal numbers are allowed.
+     *
+     * @param value - Whether to allow float values.
+     * @returns This UserInput instance for method chaining.
+     */
+    setFloat(value) {
+        UserInput.logger.verbose(`Setting float to: ${value}`);
+        this.float = value;
+        return this;
+    }
+    /**
+     * @description Sets the number of decimal places to round to for float inputs.
+     * @summary Configures the precision of float inputs.
+     *
+     * @param value - The number of decimal places.
+     * @returns This UserInput instance for method chaining.
+     */
+    setRound(value) {
+        UserInput.logger.verbose(`Setting round to: ${value}`);
+        this.round = value;
+        return this;
+    }
+    /**
+     * @description Sets the instructions for the user.
+     * @summary Configures additional guidance provided to the user.
+     *
+     * @param value - The instructions.
+     * @returns This UserInput instance for method chaining.
+     */
+    setInstructions(value) {
+        UserInput.logger.verbose(`Setting instructions to: ${value}`);
+        this.instructions = value;
+        return this;
+    }
+    /**
+     * @description Sets the increment value for number inputs.
+     * @summary Configures the step size when increasing or decreasing the number.
+     *
+     * @param value - The increment value.
+     * @returns This UserInput instance for method chaining.
+     */
+    setIncrement(value) {
+        UserInput.logger.verbose(`Setting increment to: ${value}`);
+        this.increment = value;
+        return this;
+    }
+    /**
+     * @description Sets the separator for list inputs.
+     * @summary Configures the character used to separate list items.
+     *
+     * @param value - The separator character.
+     * @returns This UserInput instance for method chaining.
+     */
+    setSeparator(value) {
+        UserInput.logger.verbose(`Setting separator to: ${value}`);
+        this.separator = value;
+        return this;
+    }
+    /**
+     * @description Sets the active option style for select inputs.
+     * @summary Configures the style applied to the currently selected option.
+     *
+     * @param value - The active option style.
+     * @returns This UserInput instance for method chaining.
+     */
+    setActive(value) {
+        UserInput.logger.verbose(`Setting active style to: ${value}`);
+        this.active = value;
+        return this;
+    }
+    /**
+     * @description Sets the inactive option style for select inputs.
+     * @summary Configures the style applied to non-selected options.
+     *
+     * @param value - The inactive option style.
+     * @returns This UserInput instance for method chaining.
+     */
+    setInactive(value) {
+        UserInput.logger.verbose(`Setting inactive style to: ${value}`);
+        this.inactive = value;
+        return this;
+    }
+    setChoices(value) {
+        UserInput.logger.verbose(`Setting choices: ${JSON.stringify(value)}`);
+        this.choices = value;
+        return this;
+    }
+    /**
+     * @description Sets the hint text for the prompt.
+     * @summary Configures additional information displayed to the user.
+     *
+     * @param value - The hint text.
+     * @returns This UserInput instance for method chaining.
+     */
+    setHint(value) {
+        UserInput.logger.verbose(`Setting hint to: ${value}`);
+        this.hint = value;
+        return this;
+    }
+    /**
+     * @description Sets the warning text for the prompt.
+     * @summary Configures a warning message displayed to the user.
+     *
+     * @param value - The warning text.
+     * @returns This UserInput instance for method chaining.
+     */
+    setWarn(value) {
+        UserInput.logger.verbose(`Setting warn to: ${value}`);
+        this.warn = value;
+        return this;
+    }
+    setSuggest(value) {
+        UserInput.logger.verbose(`Setting suggest function`);
+        this.suggest = value;
+        return this;
+    }
+    /**
+     * @description Sets the limit for list inputs.
+     * @summary Configures the maximum number of items that can be selected in list-type prompts.
+     * @template R - The type of the prompt name, extending string.
+     * @param value - The maximum number of items that can be selected, or a function to determine this value.
+     * @return This UserInput instance for method chaining.
+     */
+    setLimit(value) {
+        UserInput.logger.verbose(`Setting limit to: ${value}`);
+        this.limit = value;
+        return this;
+    }
+    /**
+     * @description Sets the mask for password inputs.
+     * @summary Configures the character used to hide the user's input in password-type prompts.
+     * @template R - The type of the prompt name, extending string.
+     * @param value - The character used to mask the input, or a function to determine this value.
+     * @return This UserInput instance for method chaining.
+     */
+    setMask(value) {
+        UserInput.logger.verbose(`Setting mask to: ${value}`);
+        this.mask = value;
+        return this;
+    }
+    /**
+     * @description Sets the stdout stream for the prompt.
+     * @summary Configures the output stream used by the prompt for displaying messages and results.
+     * @param value - The Writable stream to be used as stdout.
+     * @return This UserInput instance for method chaining.
+     */
+    setStdout(value) {
+        UserInput.logger.verbose(`Setting stdout stream`);
+        this.stdout = value;
+        return this;
+    }
+    /**
+     * @description Sets the stdin stream for the prompt.
+     * @summary Configures the input stream used by the prompt for receiving user input.
+     * @param value - The Readable stream to be used as stdin.
+     * @return This UserInput instance for method chaining.
+     */
+    setStdin(value) {
+        this.stdin = value;
+        return this;
+    }
+    /**
+     * @description Asks the user for input based on the current UserInput configuration.
+     * @summary Prompts the user and returns their response as a single value.
+     * @template R - The type of the prompt name, extending string.
+     * @return A Promise that resolves to the user's answer.
+     */
+    async ask() {
+        return (await UserInput.ask(this))[this.name];
+    }
+    /**
+     * @description Asks the user one or more questions based on the provided UserInput configurations.
+     * @summary Prompts the user with one or more questions and returns their answers as an object.
+     * @template R - The type of the prompt name, extending string.
+     * @param question - A single UserInput instance or an array of UserInput instances.
+     * @return A Promise that resolves to an object containing the user's answers.
+     * @mermaid
+     * sequenceDiagram
+     *   participant U as User
+     *   participant A as ask method
+     *   participant P as prompts library
+     *   A->>P: Call prompts with question(s)
+     *   P->>U: Display prompt(s)
+     *   U->>P: Provide input
+     *   P->>A: Return answers
+     *   A->>A: Process answers
+     *   A-->>Caller: Return processed answers
+     */
+    static async ask(question) {
+        const log = UserInput.logger.for(this.ask);
+        if (!Array.isArray(question)) {
+            question = [question];
+        }
+        let answers;
+        try {
+            log.verbose(`Asking questions: ${question.map((q) => q.name).join(", ")}`);
+            answers = await prompts(question);
+            log.verbose(`Received answers: ${JSON.stringify(answers, null, 2)}`);
+        }
+        catch (error) {
+            throw new Error(`Error while getting input: ${error}`);
+        }
+        return answers;
+    }
+    /**
+     * @description Asks the user for a number input.
+     * @summary Prompts the user to enter a number, with optional minimum, maximum, and initial values.
+     * @param name - The name of the prompt, used as the key in the returned answers object.
+     * @param question - The message displayed to the user.
+     * @param min - The minimum allowed value (optional).
+     * @param max - The maximum allowed value (optional).
+     * @param initial - The initial value presented to the user (optional).
+     * @return A Promise that resolves to the number entered by the user.
+     */
+    static async askNumber(name, question, min, max, initial) {
+        const log = UserInput.logger.for(this.askNumber);
+        log.verbose(`Asking number input: undefined, question: ${question}, min: ${min}, max: ${max}, initial: ${initial}`);
+        const userInput = new UserInput(name)
+            .setMessage(question)
+            .setType("number");
+        if (typeof min === "number")
+            userInput.setMin(min);
+        if (typeof max === "number")
+            userInput.setMax(max);
+        if (typeof initial === "number")
+            userInput.setInitial(initial);
+        return (await this.ask(userInput))[name];
+    }
+    /**
+     * @description Asks the user for a text input.
+     * @summary Prompts the user to enter text, with optional masking and initial value.
+     * @param name - The name of the prompt, used as the key in the returned answers object.
+     * @param question - The message displayed to the user.
+     * @param mask - The character used to mask the input (optional, for password-like inputs).
+     * @param initial - The initial value presented to the user (optional).
+     * @return A Promise that resolves to the text entered by the user.
+     */
+    static async askText(name, question, mask = undefined, initial) {
+        const log = UserInput.logger.for(this.askText);
+        log.verbose(`Asking text input: undefined, question: ${question}, mask: ${mask}, initial: ${initial}`);
+        const userInput = new UserInput(name).setMessage(question);
+        if (mask)
+            userInput.setMask(mask);
+        if (typeof initial === "string")
+            userInput.setInitial(initial);
+        return (await this.ask(userInput))[name];
+    }
+    /**
+     * @description Asks the user for a confirmation (yes/no).
+     * @summary Prompts the user with a yes/no question and returns a boolean result.
+     * @param name - The name of the prompt, used as the key in the returned answers object.
+     * @param question - The message displayed to the user.
+     * @param initial - The initial value presented to the user (optional).
+     * @return A Promise that resolves to a boolean representing the user's answer.
+     */
+    static async askConfirmation(name, question, initial) {
+        const log = UserInput.logger.for(this.askConfirmation);
+        log.verbose(`Asking confirmation input: undefined, question: ${question}, initial: ${initial}`);
+        const userInput = new UserInput(name)
+            .setMessage(question)
+            .setType("confirm");
+        if (typeof initial !== "undefined")
+            userInput.setInitial(initial);
+        return (await this.ask(userInput))[name];
+    }
+    /**
+     * @description Repeatedly asks for input until a valid response is given or the limit is reached.
+     * @summary This method insists on getting a valid input from the user, allowing for a specified number of attempts.
+     *
+     * @template R - The type of the expected result.
+     * @param input - The UserInput instance to use for prompting.
+     * @param test - A function to validate the user's input.
+     * @param limit - The maximum number of attempts allowed (default is 1).
+     * @param defaultConfirmation
+     * @return A Promise that resolves to the valid input or undefined if the limit is reached.
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant U as User
+     *   participant I as insist method
+     *   participant A as ask method
+     *   participant T as test function
+     *   participant C as askConfirmation method
+     *   loop Until valid input or limit reached
+     *     I->>A: Call ask with input
+     *     A->>U: Prompt user
+     *     U->>A: Provide input
+     *     A->>I: Return result
+     *     I->>T: Test result
+     *     alt Test passes
+     *       I->>C: Ask for confirmation
+     *       C->>U: Confirm input
+     *       U->>C: Provide confirmation
+     *       C->>I: Return confirmation
+     *       alt Confirmed
+     *         I-->>Caller: Return valid result
+     *       else Not confirmed
+     *         I->>I: Continue loop
+     *       end
+     *     else Test fails
+     *       I->>I: Continue loop
+     *     end
+     *   end
+     *   I-->>Caller: Return undefined if limit reached
+     */
+    static async insist(input, test, defaultConfirmation, limit = 1) {
+        const log = UserInput.logger.for(this.insist);
+        log.verbose(`Insisting on input: ${input.name}, test: ${test.toString()}, defaultConfirmation: ${defaultConfirmation}, limit: ${limit}`);
+        let result = undefined;
+        let count = 0;
+        let confirmation;
+        try {
+            do {
+                result = (await UserInput.ask(input))[input.name];
+                if (!test(result)) {
+                    result = undefined;
+                    continue;
+                }
+                confirmation = await UserInput.askConfirmation(`${input.name}-confirm`, `Is the ${input.type} correct?`, defaultConfirmation);
+                if (!confirmation)
+                    result = undefined;
+            } while (typeof result === "undefined" && limit > 1 && count++ < limit);
+        }
+        catch (e) {
+            log.error(`Error while insisting: ${e}`);
+            throw e;
+        }
+        if (typeof result === "undefined")
+            log.info("no selection...");
+        return result;
+    }
+    /**
+     * @description Repeatedly asks for text input until a valid response is given or the limit is reached.
+     * @summary This method insists on getting a valid text input from the user, allowing for a specified number of attempts.
+     *
+     * @param name - The name of the prompt, used as the key in the returned answers object.
+     * @param question - The message displayed to the user.
+     * @param test - A function to validate the user's input.
+     * @param mask - The character used to mask the input (optional, for password-like inputs).
+     * @param initial - The initial value presented to the user (optional).
+     * @param defaultConfirmation
+     * @param limit - The maximum number of attempts allowed (default is -1, meaning unlimited).
+     * @return A Promise that resolves to the valid input or undefined if the limit is reached.
+     */
+    static async insistForText(name, question, test, mask = undefined, initial, defaultConfirmation = false, limit = -1) {
+        const log = UserInput.logger.for(this.insistForText);
+        log.verbose(`Insisting for text input: undefined, question: ${question}, test: ${test.toString()}, mask: ${mask}, initial: ${initial}, defaultConfirmation: ${defaultConfirmation}, limit: ${limit}`);
+        const userInput = new UserInput(name).setMessage(question);
+        if (mask)
+            userInput.setMask(mask);
+        if (typeof initial === "string")
+            userInput.setInitial(initial);
+        return (await this.insist(userInput, test, defaultConfirmation, limit));
+    }
+    /**
+     * @description Repeatedly asks for number input until a valid response is given or the limit is reached.
+     * @summary This method insists on getting a valid number input from the user, allowing for a specified number of attempts.
+     *
+     * @param name - The name of the prompt, used as the key in the returned answers object.
+     * @param question - The message displayed to the user.
+     * @param test - A function to validate the user's input.
+     * @param min - The minimum allowed value (optional).
+     * @param max - The maximum allowed value (optional).
+     * @param initial - The initial value presented to the user (optional).
+     * @param defaultConfirmation
+     * @param limit - The maximum number of attempts allowed (default is -1, meaning unlimited).
+     * @return A Promise that resolves to the valid input or undefined if the limit is reached.
+     */
+    static async insistForNumber(name, question, test, min, max, initial, defaultConfirmation = false, limit = -1) {
+        const log = UserInput.logger.for(this.insistForNumber);
+        log.verbose(`Insisting for number input: undefined, question: ${question}, test: ${test.toString()}, min: ${min}, max: ${max}, initial: ${initial}, defaultConfirmation: ${defaultConfirmation}, limit: ${limit}`);
+        const userInput = new UserInput(name)
+            .setMessage(question)
+            .setType("number");
+        if (typeof min === "number")
+            userInput.setMin(min);
+        if (typeof max === "number")
+            userInput.setMax(max);
+        if (typeof initial === "number")
+            userInput.setInitial(initial);
+        return (await this.insist(userInput, test, defaultConfirmation, limit));
+    }
+    /**
+     * @description Parses command-line arguments based on the provided options.
+     * @summary Uses Node.js's util.parseArgs to parse command-line arguments and return the result.
+     * @param options - Configuration options for parsing arguments.
+     * @return An object containing the parsed arguments.
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Caller
+     *   participant P as parseArgs method
+     *   participant U as util.parseArgs
+     *   C->>P: Call with options
+     *   P->>P: Prepare args object
+     *   P->>U: Call parseArgs with prepared args
+     *   U->>P: Return parsed result
+     *   P-->>C: Return ParseArgsResult
+     */
+    static parseArgs(options) {
+        const log = UserInput.logger.for(this.parseArgs);
+        const args = {
+            args: process.argv.slice(2),
+            options: options,
+        };
+        log.debug(`Parsing arguments: ${JSON.stringify(args, null, 2)}`);
+        try {
+            return parseArgs(args);
+        }
+        catch (error) {
+            log.debug(`Error while parsing arguments:\n${JSON.stringify(args, null, 2)}\n | options\n${JSON.stringify(options, null, 2)}\n | ${error}`);
+            throw new Error(`Error while parsing arguments: ${error}`);
+        }
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/input/input.ts"],"names":[],"mappings":"AAAA,OAAO,OASN,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,SAAS,EAAmB,MAAM,MAAM,CAAC;AAElD,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAI5C;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,SAAS;aACI,WAAM,GAAG,OAAO,CAAC,GAAG,CAAC,SAAS,CAAxB,AAAyB,CAAC;IAsJxD;;;;;OAKG;IACH,YAAY,IAAoB;QA3JhC;;;WAGG;QACH,SAAI,GAA2D,MAAM,CAAC;QAwJpE,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED;;;;;;OAMG;IACH,OAAO,CAAC,IAA4D;QAClE,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,oBAAoB,IAAI,EAAE,CAAC,CAAC;QACrD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,UAAU,CAAC,KAAsC;QAC/C,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,uBAAuB,KAAK,EAAE,CAAC,CAAC;QACzD,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,UAAU,CACR,KAGa;QAEb,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,6BAA6B,KAAK,EAAE,CAAC,CAAC;QAC/D,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,KAAyD;QAChE,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,qBAAqB,KAAK,EAAE,CAAC,CAAC;QACvD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,SAAS,CAAC,KAAsC;QAC9C,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,yBAAyB,CAAC,CAAC;QACpD,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,WAAW,CACT,KAEa;QAEb,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,2BAA2B,CAAC,CAAC;QACtD,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,UAAU,CAAC,KAAsC;QAC/C,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,0BAA0B,CAAC,CAAC;QACrD,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,WAAW,CAAC,KAA2C;QACrD,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,2BAA2B,CAAC,CAAC;QACtD,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,KAAyD;QAC9D,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,yBAAyB,KAAK,EAAE,CAAC,CAAC;QAC3D,IAAI,CAAC,GAAG,GAAG,KAAK,CAAC;QACjB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,KAAyD;QAC9D,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,yBAAyB,KAAK,EAAE,CAAC,CAAC;QAC3D,IAAI,CAAC,GAAG,GAAG,KAAK,CAAC;QACjB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,KAA2D;QAClE,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,qBAAqB,KAAK,EAAE,CAAC,CAAC;QACvD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,KAAyD;QAChE,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,qBAAqB,KAAK,EAAE,CAAC,CAAC;QACvD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,eAAe,CAAC,KAAmC;QACjD,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,4BAA4B,KAAK,EAAE,CAAC,CAAC;QAC9D,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,YAAY,CACV,KAAyD;QAEzD,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,yBAAyB,KAAK,EAAE,CAAC,CAAC;QAC3D,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,YAAY,CACV,KAAyD;QAEzD,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,yBAAyB,KAAK,EAAE,CAAC,CAAC;QAC3D,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,SAAS,CAAC,KAAyD;QACjE,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,4BAA4B,KAAK,EAAE,CAAC,CAAC;QAC9D,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,WAAW,CAAC,KAAyD;QACnE,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,8BAA8B,KAAK,EAAE,CAAC,CAAC;QAChE,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,UAAU,CACR,KAA6D;QAE7D,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,oBAAoB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACtE,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,OAAO,CAAC,KAAyD;QAC/D,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,oBAAoB,KAAK,EAAE,CAAC,CAAC;QACtD,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;QAClB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,OAAO,CAAC,KAAyD;QAC/D,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,oBAAoB,KAAK,EAAE,CAAC,CAAC;QACtD,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;QAClB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,UAAU,CACR,KAAoE;QAEpE,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,0BAA0B,CAAC,CAAC;QACrD,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,KAAyD;QAChE,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,qBAAqB,KAAK,EAAE,CAAC,CAAC;QACvD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,OAAO,CAAC,KAAyD;QAC/D,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,oBAAoB,KAAK,EAAE,CAAC,CAAC;QACtD,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;QAClB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,SAAS,CAAC,KAA2B;QACnC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,uBAAuB,CAAC,CAAC;QAClD,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,OAAO,IAAI,CAAC;IACd,CAAC;IACD;;;;;OAKG;IACH,QAAQ,CAAC,KAA2B;QAClC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,GAAG;QACP,OAAO,CAAC,MAAM,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAwB,CAAC,CAAC;IACpE,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,KAAK,CAAC,GAAG,CACd,QAAuC;QAEvC,MAAM,GAAG,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC3C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC7B,QAAQ,GAAG,CAAC,QAAQ,CAAC,CAAC;QACxB,CAAC;QACD,IAAI,OAAmB,CAAC;QACxB,IAAI,CAAC;YACH,GAAG,CAAC,OAAO,CACT,qBAAqB,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC9D,CAAC;YACF,OAAO,GAAG,MAAM,OAAO,CAAC,QAAQ,CAAC,CAAC;YAClC,GAAG,CAAC,OAAO,CAAC,qBAAqB,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;QACvE,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CAAC,8BAA8B,KAAK,EAAE,CAAC,CAAC;QACzD,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,KAAK,CAAC,SAAS,CACpB,IAAY,EACZ,QAAgB,EAChB,GAAY,EACZ,GAAY,EACZ,OAAgB;QAEhB,MAAM,GAAG,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACjD,GAAG,CAAC,OAAO,CACT,6CAA6C,QAAQ,UAAU,GAAG,UAAU,GAAG,cAAc,OAAO,EAAE,CACvG,CAAC;QACF,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC;aAClC,UAAU,CAAC,QAAQ,CAAC;aACpB,OAAO,CAAC,QAAQ,CAAC,CAAC;QAErB,IAAI,OAAO,GAAG,KAAK,QAAQ;YAAE,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAEnD,IAAI,OAAO,GAAG,KAAK,QAAQ;YAAE,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAEnD,IAAI,OAAO,OAAO,KAAK,QAAQ;YAAE,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAE/D,OAAO,CAAC,MAAM,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,KAAK,CAAC,OAAO,CAClB,IAAY,EACZ,QAAgB,EAChB,OAA2B,SAAS,EACpC,OAAgB;QAEhB,MAAM,GAAG,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC/C,GAAG,CAAC,OAAO,CACT,2CAA2C,QAAQ,WAAW,IAAI,cAAc,OAAO,EAAE,CAC1F,CAAC;QACF,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QAE3D,IAAI,IAAI;YAAE,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAClC,IAAI,OAAO,OAAO,KAAK,QAAQ;YAAE,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAC/D,OAAO,CAAC,MAAM,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,KAAK,CAAC,eAAe,CAC1B,IAAY,EACZ,QAAgB,EAChB,OAAiB;QAEjB,MAAM,GAAG,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACvD,GAAG,CAAC,OAAO,CACT,mDAAmD,QAAQ,cAAc,OAAO,EAAE,CACnF,CAAC;QACF,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC;aAClC,UAAU,CAAC,QAAQ,CAAC;aACpB,OAAO,CAAC,SAAS,CAAC,CAAC;QAEtB,IAAI,OAAO,OAAO,KAAK,WAAW;YAAE,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAClE,OAAO,CAAC,MAAM,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;IACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACH,MAAM,CAAC,KAAK,CAAC,MAAM,CACjB,KAAgB,EAChB,IAAuC,EACvC,mBAA4B,EAC5B,KAAK,GAAG,CAAC;QAET,MAAM,GAAG,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC9C,GAAG,CAAC,OAAO,CACT,uBAAuB,KAAK,CAAC,IAAI,WAAW,IAAI,CAAC,QAAQ,EAAE,0BAA0B,mBAAmB,YAAY,KAAK,EAAE,CAC5H,CAAC;QACF,IAAI,MAAM,GAAgC,SAAS,CAAC;QACpD,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,YAAqB,CAAC;QAC1B,IAAI,CAAC;YACH,GAAG,CAAC;gBACF,MAAM,GAAG,CAAC,MAAM,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CACnC,KAAK,CAAC,IAA6B,CAC1B,CAAC;gBACZ,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;oBAClB,MAAM,GAAG,SAAS,CAAC;oBACnB,SAAS;gBACX,CAAC;gBACD,YAAY,GAAG,MAAM,SAAS,CAAC,eAAe,CAC5C,GAAG,KAAK,CAAC,IAAI,UAAU,EACvB,UAAU,KAAK,CAAC,IAAI,WAAW,EAC/B,mBAAmB,CACpB,CAAC;gBACF,IAAI,CAAC,YAAY;oBAAE,MAAM,GAAG,SAAS,CAAC;YACxC,CAAC,QAAQ,OAAO,MAAM,KAAK,WAAW,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,EAAE,GAAG,KAAK,EAAE;QAC1E,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,GAAG,CAAC,KAAK,CAAC,0BAA0B,CAAC,EAAE,CAAC,CAAC;YACzC,MAAM,CAAC,CAAC;QACV,CAAC;QAED,IAAI,OAAO,MAAM,KAAK,WAAW;YAAE,GAAG,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAC/D,OAAO,MAAuB,CAAC;IACjC,CAAC;IACD;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,KAAK,CAAC,aAAa,CACxB,IAAY,EACZ,QAAgB,EAChB,IAA8B,EAC9B,OAA2B,SAAS,EACpC,OAAgB,EAChB,mBAAmB,GAAG,KAAK,EAC3B,KAAK,GAAG,CAAC,CAAC;QAEV,MAAM,GAAG,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACrD,GAAG,CAAC,OAAO,CACT,kDAAkD,QAAQ,WAAW,IAAI,CAAC,QAAQ,EAAE,WAAW,IAAI,cAAc,OAAO,0BAA0B,mBAAmB,YAAY,KAAK,EAAE,CACzL,CAAC;QACF,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QAE3D,IAAI,IAAI;YAAE,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAClC,IAAI,OAAO,OAAO,KAAK,QAAQ;YAAE,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAC/D,OAAO,CAAC,MAAM,IAAI,CAAC,MAAM,CACvB,SAAS,EACT,IAAyC,EACzC,mBAAmB,EACnB,KAAK,CACN,CAAW,CAAC;IACf,CAAC;IACD;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,KAAK,CAAC,eAAe,CAC1B,IAAY,EACZ,QAAgB,EAChB,IAA8B,EAC9B,GAAY,EACZ,GAAY,EACZ,OAAgB,EAChB,mBAAmB,GAAG,KAAK,EAC3B,KAAK,GAAG,CAAC,CAAC;QAEV,MAAM,GAAG,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACvD,GAAG,CAAC,OAAO,CACT,oDAAoD,QAAQ,WAAW,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,cAAc,OAAO,0BAA0B,mBAAmB,YAAY,KAAK,EAAE,CACtM,CAAC;QACF,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC;aAClC,UAAU,CAAC,QAAQ,CAAC;aACpB,OAAO,CAAC,QAAQ,CAAC,CAAC;QAErB,IAAI,OAAO,GAAG,KAAK,QAAQ;YAAE,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAEnD,IAAI,OAAO,GAAG,KAAK,QAAQ;YAAE,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAEnD,IAAI,OAAO,OAAO,KAAK,QAAQ;YAAE,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAC/D,OAAO,CAAC,MAAM,IAAI,CAAC,MAAM,CACvB,SAAS,EACT,IAAyC,EACzC,mBAAmB,EACnB,KAAK,CACN,CAAW,CAAC;IACf,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,SAAS,CAAC,OAA+B;QAC9C,MAAM,GAAG,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACjD,MAAM,IAAI,GAAoB;YAC5B,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;YAC3B,OAAO,EAAE,OAAO;SACjB,CAAC;QACF,GAAG,CAAC,KAAK,CAAC,sBAAsB,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;QACjE,IAAI,CAAC;YACH,OAAO,SAAS,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,GAAG,CAAC,KAAK,CACP,mCAAmC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,iBAAiB,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,QAAQ,KAAK,EAAE,CACjI,CAAC;YACF,MAAM,IAAI,KAAK,CAAC,kCAAkC,KAAK,EAAE,CAAC,CAAC;QAC7D,CAAC;IACH,CAAC","file":"input/input.js","sourcesContent":["import prompts, {\n  Answers,\n  Choice,\n  Falsy,\n  InitialReturnValue,\n  PrevCaller,\n  PromptObject,\n  PromptType,\n  ValueOrFunc,\n} from \"prompts\";\nimport { parseArgs, ParseArgsConfig } from \"util\";\nimport { Writable, Readable } from \"stream\";\nimport { Logging } from \"../output/logging\";\nimport { Kleur } from \"../output/types\";\nimport { ParseArgsOptionsConfig, ParseArgsResult } from \"./types\";\n\n/**\n * @description Represents a user input prompt with various configuration options.\n * @summary This class provides a flexible interface for creating and managing user input prompts.\n * It implements the PromptObject interface from the 'prompts' library and offers methods to set\n * various properties of the prompt. The class also includes static methods for common input scenarios\n * and argument parsing.\n *\n * @template R - The type of the prompt name, extending string.\n *\n * @param name - The name of the prompt, used as the key in the returned answers object.\n *\n * @class\n */\nexport class UserInput<R extends string = string> implements PromptObject<R> {\n  private static readonly logger = Logging.for(UserInput);\n  /**\n   * @description The type of the prompt.\n   * @summary Determines the input method (e.g., text, number, confirm).\n   */\n  type: PromptType | Falsy | PrevCaller<R, PromptType | Falsy> = \"text\";\n\n  /**\n   * @description The name of the prompt.\n   * @summary Used as the key in the returned answers object.\n   */\n  name: ValueOrFunc<R>;\n\n  /**\n   * @description The message displayed to the user.\n   * @summary The question or instruction presented to the user.\n   */\n  message?: ValueOrFunc<string> | undefined;\n\n  /**\n   * @description The initial value of the prompt.\n   * @summary The default value presented to the user.\n   */\n  initial?:\n    | InitialReturnValue\n    | PrevCaller<R, InitialReturnValue | Promise<InitialReturnValue>>\n    | undefined;\n\n  /**\n   * @description The style of the prompt.\n   * @summary Determines the visual style of the prompt.\n   */\n  style?: string | PrevCaller<R, string | Falsy> | undefined;\n\n  /**\n   * @description The format function for the input.\n   * @summary A function to format the user's input before it's returned.\n   */\n  format?: PrevCaller<R, void> | undefined;\n\n  /**\n   * @description The validation function for the input.\n   * @summary A function to validate the user's input.\n   */\n  validate?:\n    | PrevCaller<R, boolean | string | Promise<boolean | string>>\n    | undefined;\n\n  /**\n   * @description The onState callback function.\n   * @summary A function called when the state of the prompt changes.\n   */\n  onState?: PrevCaller<R, void> | undefined;\n\n  onRender?: ((kleur: Kleur) => void) | undefined;\n\n  /**\n   * @description The minimum value for number inputs.\n   * @summary The lowest number the user can input.\n   */\n  min?: number | PrevCaller<R, number | Falsy> | undefined;\n\n  /**\n   * @description The maximum value for number inputs.\n   * @summary The highest number the user can input.\n   */\n  max?: number | PrevCaller<R, number | Falsy> | undefined;\n\n  /**\n   * @description Whether to allow float values for number inputs.\n   * @summary If true, allows decimal numbers.\n   */\n  float?: boolean | PrevCaller<R, boolean | Falsy> | undefined;\n\n  /**\n   * @description The number of decimal places to round to for float inputs.\n   * @summary Determines the precision of float inputs.\n   */\n  round?: number | PrevCaller<R, number | Falsy> | undefined;\n\n  /**\n   * @description Instructions for the user.\n   * @summary Additional guidance provided to the user.\n   */\n  instructions?: string | boolean | undefined;\n\n  /**\n   * @description The increment value for number inputs.\n   * @summary The step size when increasing or decreasing the number.\n   */\n  increment?: number | PrevCaller<R, number | Falsy> | undefined;\n\n  /**\n   * @description The separator for list inputs.\n   * @summary The character used to separate list items.\n   */\n  separator?: string | PrevCaller<R, string | Falsy> | undefined;\n\n  /**\n   * @description The active option style for select inputs.\n   * @summary The style applied to the currently selected option.\n   */\n  active?: string | PrevCaller<R, string | Falsy> | undefined;\n\n  /**\n   * @description The inactive option style for select inputs.\n   * @summary The style applied to non-selected options.\n   */\n  inactive?: string | PrevCaller<R, string | Falsy> | undefined;\n\n  choices?: Choice[] | PrevCaller<R, Choice[] | Falsy> | undefined;\n\n  /**\n   * @description The hint text for the prompt.\n   * @summary Additional information displayed to the user.\n   */\n  hint?: string | PrevCaller<R, string | Falsy> | undefined;\n\n  /**\n   * @description The warning text for the prompt.\n   * @summary A warning message displayed to the user.\n   */\n  warn?: string | PrevCaller<R, string | Falsy> | undefined;\n\n  suggest?: ((input: any, choices: Choice[]) => Promise<any>) | undefined;\n\n  /**\n   * @description The limit for list inputs.\n   * @summary The maximum number of items that can be selected.\n   */\n  limit?: number | PrevCaller<R, number | Falsy> | undefined;\n\n  /**\n   * @description The mask for password inputs.\n   * @summary The character used to hide the user's input.\n   */\n  mask?: string | PrevCaller<R, string | Falsy> | undefined;\n\n  /**\n   * @description The stdout stream for the prompt.\n   * @summary The output stream used by the prompt.\n   */\n  stdout?: Writable | undefined;\n\n  /**\n   * @description The stdin stream for the prompt.\n   * @summary The input stream used by the prompt.\n   */\n  stdin?: Readable | undefined;\n\n  /**\n   * @description Creates a new UserInput instance.\n   * @summary Initializes a new UserInput object with the given name.\n   *\n   * @param name - The name of the prompt.\n   */\n  constructor(name: ValueOrFunc<R>) {\n    this.name = name;\n  }\n\n  /**\n   * @description Sets the type of the prompt.\n   * @summary Configures the input method for the prompt.\n   *\n   * @param type - The type of the prompt.\n   * @returns This UserInput instance for method chaining.\n   */\n  setType(type: PromptType | Falsy | PrevCaller<R, PromptType | Falsy>): this {\n    UserInput.logger.verbose(`Setting type to: ${type}`);\n    this.type = type;\n    return this;\n  }\n\n  /**\n   * @description Sets the message of the prompt.\n   * @summary Configures the question or instruction presented to the user.\n   *\n   * @param value - The message to be displayed.\n   * @returns This UserInput instance for method chaining.\n   */\n  setMessage(value: ValueOrFunc<string> | undefined): this {\n    UserInput.logger.verbose(`Setting message to: ${value}`);\n    this.message = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the initial value of the prompt.\n   * @summary Configures the default value presented to the user.\n   *\n   * @param value - The initial value.\n   * @returns This UserInput instance for method chaining.\n   */\n  setInitial(\n    value:\n      | InitialReturnValue\n      | PrevCaller<R, InitialReturnValue | Promise<InitialReturnValue>>\n      | undefined\n  ): this {\n    UserInput.logger.verbose(`Setting initial value to: ${value}`);\n    this.initial = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the style of the prompt.\n   * @summary Configures the visual style of the prompt.\n   *\n   * @param value - The style to be applied.\n   * @returns This UserInput instance for method chaining.\n   */\n  setStyle(value: string | PrevCaller<R, string | Falsy> | undefined): this {\n    UserInput.logger.verbose(`Setting style to: ${value}`);\n    this.style = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the format function of the prompt.\n   * @summary Configures a function to format the user's input before it's returned.\n   *\n   * @param value - The format function.\n   * @returns This UserInput instance for method chaining.\n   */\n  setFormat(value: PrevCaller<R, void> | undefined): this {\n    UserInput.logger.verbose(`Setting format function`);\n    this.format = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the validation function of the prompt.\n   * @summary Configures a function to validate the user's input.\n   *\n   * @param value - The validation function.\n   * @returns This UserInput instance for method chaining.\n   */\n  setValidate(\n    value:\n      | PrevCaller<R, boolean | string | Promise<boolean | string>>\n      | undefined\n  ): this {\n    UserInput.logger.verbose(`Setting validate function`);\n    this.validate = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the onState callback of the prompt.\n   * @summary Configures a function to be called when the state of the prompt changes.\n   *\n   * @param value - The onState callback function.\n   * @returns This UserInput instance for method chaining.\n   */\n  setOnState(value: PrevCaller<R, void> | undefined): this {\n    UserInput.logger.verbose(`Setting onState callback`);\n    this.onState = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the onRender callback of the prompt.\n   * @summary Configures a function to be called when the prompt is rendered.\n   *\n   * @param value - The onRender callback function.\n   * @returns This UserInput instance for method chaining.\n   */\n  setOnRender(value: ((kleur: Kleur) => void) | undefined): this {\n    UserInput.logger.verbose(`Setting onRender callback`);\n    this.onRender = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the minimum value for number inputs.\n   * @summary Configures the lowest number the user can input.\n   *\n   * @param value - The minimum value.\n   * @returns This UserInput instance for method chaining.\n   */\n  setMin(value: number | PrevCaller<R, number | Falsy> | undefined): this {\n    UserInput.logger.verbose(`Setting min value to: ${value}`);\n    this.min = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the maximum value for number inputs.\n   * @summary Configures the highest number the user can input.\n   *\n   * @param value - The maximum value.\n   * @returns This UserInput instance for method chaining.\n   */\n  setMax(value: number | PrevCaller<R, number | Falsy> | undefined): this {\n    UserInput.logger.verbose(`Setting max value to: ${value}`);\n    this.max = value;\n    return this;\n  }\n\n  /**\n   * @description Sets whether to allow float values for number inputs.\n   * @summary Configures whether decimal numbers are allowed.\n   *\n   * @param value - Whether to allow float values.\n   * @returns This UserInput instance for method chaining.\n   */\n  setFloat(value: boolean | PrevCaller<R, boolean | Falsy> | undefined): this {\n    UserInput.logger.verbose(`Setting float to: ${value}`);\n    this.float = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the number of decimal places to round to for float inputs.\n   * @summary Configures the precision of float inputs.\n   *\n   * @param value - The number of decimal places.\n   * @returns This UserInput instance for method chaining.\n   */\n  setRound(value: number | PrevCaller<R, number | Falsy> | undefined): this {\n    UserInput.logger.verbose(`Setting round to: ${value}`);\n    this.round = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the instructions for the user.\n   * @summary Configures additional guidance provided to the user.\n   *\n   * @param value - The instructions.\n   * @returns This UserInput instance for method chaining.\n   */\n  setInstructions(value: string | boolean | undefined): this {\n    UserInput.logger.verbose(`Setting instructions to: ${value}`);\n    this.instructions = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the increment value for number inputs.\n   * @summary Configures the step size when increasing or decreasing the number.\n   *\n   * @param value - The increment value.\n   * @returns This UserInput instance for method chaining.\n   */\n  setIncrement(\n    value: number | PrevCaller<R, number | Falsy> | undefined\n  ): this {\n    UserInput.logger.verbose(`Setting increment to: ${value}`);\n    this.increment = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the separator for list inputs.\n   * @summary Configures the character used to separate list items.\n   *\n   * @param value - The separator character.\n   * @returns This UserInput instance for method chaining.\n   */\n  setSeparator(\n    value: string | PrevCaller<R, string | Falsy> | undefined\n  ): this {\n    UserInput.logger.verbose(`Setting separator to: ${value}`);\n    this.separator = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the active option style for select inputs.\n   * @summary Configures the style applied to the currently selected option.\n   *\n   * @param value - The active option style.\n   * @returns This UserInput instance for method chaining.\n   */\n  setActive(value: string | PrevCaller<R, string | Falsy> | undefined): this {\n    UserInput.logger.verbose(`Setting active style to: ${value}`);\n    this.active = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the inactive option style for select inputs.\n   * @summary Configures the style applied to non-selected options.\n   *\n   * @param value - The inactive option style.\n   * @returns This UserInput instance for method chaining.\n   */\n  setInactive(value: string | PrevCaller<R, string | Falsy> | undefined): this {\n    UserInput.logger.verbose(`Setting inactive style to: ${value}`);\n    this.inactive = value;\n    return this;\n  }\n\n  setChoices(\n    value: Choice[] | PrevCaller<R, Choice[] | Falsy> | undefined\n  ): this {\n    UserInput.logger.verbose(`Setting choices: ${JSON.stringify(value)}`);\n    this.choices = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the hint text for the prompt.\n   * @summary Configures additional information displayed to the user.\n   *\n   * @param value - The hint text.\n   * @returns This UserInput instance for method chaining.\n   */\n  setHint(value: string | PrevCaller<R, string | Falsy> | undefined): this {\n    UserInput.logger.verbose(`Setting hint to: ${value}`);\n    this.hint = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the warning text for the prompt.\n   * @summary Configures a warning message displayed to the user.\n   *\n   * @param value - The warning text.\n   * @returns This UserInput instance for method chaining.\n   */\n  setWarn(value: string | PrevCaller<R, string | Falsy> | undefined): this {\n    UserInput.logger.verbose(`Setting warn to: ${value}`);\n    this.warn = value;\n    return this;\n  }\n\n  setSuggest(\n    value: ((input: any, choices: Choice[]) => Promise<any>) | undefined\n  ): this {\n    UserInput.logger.verbose(`Setting suggest function`);\n    this.suggest = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the limit for list inputs.\n   * @summary Configures the maximum number of items that can be selected in list-type prompts.\n   * @template R - The type of the prompt name, extending string.\n   * @param value - The maximum number of items that can be selected, or a function to determine this value.\n   * @return This UserInput instance for method chaining.\n   */\n  setLimit(value: number | PrevCaller<R, number | Falsy> | undefined): this {\n    UserInput.logger.verbose(`Setting limit to: ${value}`);\n    this.limit = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the mask for password inputs.\n   * @summary Configures the character used to hide the user's input in password-type prompts.\n   * @template R - The type of the prompt name, extending string.\n   * @param value - The character used to mask the input, or a function to determine this value.\n   * @return This UserInput instance for method chaining.\n   */\n  setMask(value: string | PrevCaller<R, string | Falsy> | undefined): this {\n    UserInput.logger.verbose(`Setting mask to: ${value}`);\n    this.mask = value;\n    return this;\n  }\n\n  /**\n   * @description Sets the stdout stream for the prompt.\n   * @summary Configures the output stream used by the prompt for displaying messages and results.\n   * @param value - The Writable stream to be used as stdout.\n   * @return This UserInput instance for method chaining.\n   */\n  setStdout(value: Writable | undefined): this {\n    UserInput.logger.verbose(`Setting stdout stream`);\n    this.stdout = value;\n    return this;\n  }\n  /**\n   * @description Sets the stdin stream for the prompt.\n   * @summary Configures the input stream used by the prompt for receiving user input.\n   * @param value - The Readable stream to be used as stdin.\n   * @return This UserInput instance for method chaining.\n   */\n  setStdin(value: Readable | undefined): this {\n    this.stdin = value;\n    return this;\n  }\n\n  /**\n   * @description Asks the user for input based on the current UserInput configuration.\n   * @summary Prompts the user and returns their response as a single value.\n   * @template R - The type of the prompt name, extending string.\n   * @return A Promise that resolves to the user's answer.\n   */\n  async ask() {\n    return (await UserInput.ask(this))[this.name as keyof Answers<R>];\n  }\n\n  /**\n   * @description Asks the user one or more questions based on the provided UserInput configurations.\n   * @summary Prompts the user with one or more questions and returns their answers as an object.\n   * @template R - The type of the prompt name, extending string.\n   * @param question - A single UserInput instance or an array of UserInput instances.\n   * @return A Promise that resolves to an object containing the user's answers.\n   * @mermaid\n   * sequenceDiagram\n   *   participant U as User\n   *   participant A as ask method\n   *   participant P as prompts library\n   *   A->>P: Call prompts with question(s)\n   *   P->>U: Display prompt(s)\n   *   U->>P: Provide input\n   *   P->>A: Return answers\n   *   A->>A: Process answers\n   *   A-->>Caller: Return processed answers\n   */\n  static async ask<R extends string = string>(\n    question: UserInput<R> | UserInput<R>[]\n  ) {\n    const log = UserInput.logger.for(this.ask);\n    if (!Array.isArray(question)) {\n      question = [question];\n    }\n    let answers: Answers<R>;\n    try {\n      log.verbose(\n        `Asking questions: ${question.map((q) => q.name).join(\", \")}`\n      );\n      answers = await prompts(question);\n      log.verbose(`Received answers: ${JSON.stringify(answers, null, 2)}`);\n    } catch (error: unknown) {\n      throw new Error(`Error while getting input: ${error}`);\n    }\n    return answers;\n  }\n\n  /**\n   * @description Asks the user for a number input.\n   * @summary Prompts the user to enter a number, with optional minimum, maximum, and initial values.\n   * @param name - The name of the prompt, used as the key in the returned answers object.\n   * @param question - The message displayed to the user.\n   * @param min - The minimum allowed value (optional).\n   * @param max - The maximum allowed value (optional).\n   * @param initial - The initial value presented to the user (optional).\n   * @return A Promise that resolves to the number entered by the user.\n   */\n  static async askNumber(\n    name: string,\n    question: string,\n    min?: number,\n    max?: number,\n    initial?: number\n  ): Promise<number> {\n    const log = UserInput.logger.for(this.askNumber);\n    log.verbose(\n      `Asking number input: undefined, question: ${question}, min: ${min}, max: ${max}, initial: ${initial}`\n    );\n    const userInput = new UserInput(name)\n      .setMessage(question)\n      .setType(\"number\");\n\n    if (typeof min === \"number\") userInput.setMin(min);\n\n    if (typeof max === \"number\") userInput.setMax(max);\n\n    if (typeof initial === \"number\") userInput.setInitial(initial);\n\n    return (await this.ask(userInput))[name];\n  }\n\n  /**\n   * @description Asks the user for a text input.\n   * @summary Prompts the user to enter text, with optional masking and initial value.\n   * @param name - The name of the prompt, used as the key in the returned answers object.\n   * @param question - The message displayed to the user.\n   * @param mask - The character used to mask the input (optional, for password-like inputs).\n   * @param initial - The initial value presented to the user (optional).\n   * @return A Promise that resolves to the text entered by the user.\n   */\n  static async askText(\n    name: string,\n    question: string,\n    mask: string | undefined = undefined,\n    initial?: string\n  ): Promise<string> {\n    const log = UserInput.logger.for(this.askText);\n    log.verbose(\n      `Asking text input: undefined, question: ${question}, mask: ${mask}, initial: ${initial}`\n    );\n    const userInput = new UserInput(name).setMessage(question);\n\n    if (mask) userInput.setMask(mask);\n    if (typeof initial === \"string\") userInput.setInitial(initial);\n    return (await this.ask(userInput))[name];\n  }\n\n  /**\n   * @description Asks the user for a confirmation (yes/no).\n   * @summary Prompts the user with a yes/no question and returns a boolean result.\n   * @param name - The name of the prompt, used as the key in the returned answers object.\n   * @param question - The message displayed to the user.\n   * @param initial - The initial value presented to the user (optional).\n   * @return A Promise that resolves to a boolean representing the user's answer.\n   */\n  static async askConfirmation(\n    name: string,\n    question: string,\n    initial?: boolean\n  ): Promise<boolean> {\n    const log = UserInput.logger.for(this.askConfirmation);\n    log.verbose(\n      `Asking confirmation input: undefined, question: ${question}, initial: ${initial}`\n    );\n    const userInput = new UserInput(name)\n      .setMessage(question)\n      .setType(\"confirm\");\n\n    if (typeof initial !== \"undefined\") userInput.setInitial(initial);\n    return (await this.ask(userInput))[name];\n  }\n  /**\n   * @description Repeatedly asks for input until a valid response is given or the limit is reached.\n   * @summary This method insists on getting a valid input from the user, allowing for a specified number of attempts.\n   *\n   * @template R - The type of the expected result.\n   * @param input - The UserInput instance to use for prompting.\n   * @param test - A function to validate the user's input.\n   * @param limit - The maximum number of attempts allowed (default is 1).\n   * @param defaultConfirmation\n   * @return A Promise that resolves to the valid input or undefined if the limit is reached.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant U as User\n   *   participant I as insist method\n   *   participant A as ask method\n   *   participant T as test function\n   *   participant C as askConfirmation method\n   *   loop Until valid input or limit reached\n   *     I->>A: Call ask with input\n   *     A->>U: Prompt user\n   *     U->>A: Provide input\n   *     A->>I: Return result\n   *     I->>T: Test result\n   *     alt Test passes\n   *       I->>C: Ask for confirmation\n   *       C->>U: Confirm input\n   *       U->>C: Provide confirmation\n   *       C->>I: Return confirmation\n   *       alt Confirmed\n   *         I-->>Caller: Return valid result\n   *       else Not confirmed\n   *         I->>I: Continue loop\n   *       end\n   *     else Test fails\n   *       I->>I: Continue loop\n   *     end\n   *   end\n   *   I-->>Caller: Return undefined if limit reached\n   */\n  static async insist<R>(\n    input: UserInput,\n    test: (res: string | number) => boolean,\n    defaultConfirmation: boolean,\n    limit = 1\n  ): Promise<R | undefined> {\n    const log = UserInput.logger.for(this.insist);\n    log.verbose(\n      `Insisting on input: ${input.name}, test: ${test.toString()}, defaultConfirmation: ${defaultConfirmation}, limit: ${limit}`\n    );\n    let result: string | number | undefined = undefined;\n    let count = 0;\n    let confirmation: boolean;\n    try {\n      do {\n        result = (await UserInput.ask(input))[\n          input.name as keyof Answers<string>\n        ] as string;\n        if (!test(result)) {\n          result = undefined;\n          continue;\n        }\n        confirmation = await UserInput.askConfirmation(\n          `${input.name}-confirm`,\n          `Is the ${input.type} correct?`,\n          defaultConfirmation\n        );\n        if (!confirmation) result = undefined;\n      } while (typeof result === \"undefined\" && limit > 1 && count++ < limit);\n    } catch (e: unknown) {\n      log.error(`Error while insisting: ${e}`);\n      throw e;\n    }\n\n    if (typeof result === \"undefined\") log.info(\"no selection...\");\n    return result as R | undefined;\n  }\n  /**\n   * @description Repeatedly asks for text input until a valid response is given or the limit is reached.\n   * @summary This method insists on getting a valid text input from the user, allowing for a specified number of attempts.\n   *\n   * @param name - The name of the prompt, used as the key in the returned answers object.\n   * @param question - The message displayed to the user.\n   * @param test - A function to validate the user's input.\n   * @param mask - The character used to mask the input (optional, for password-like inputs).\n   * @param initial - The initial value presented to the user (optional).\n   * @param defaultConfirmation\n   * @param limit - The maximum number of attempts allowed (default is -1, meaning unlimited).\n   * @return A Promise that resolves to the valid input or undefined if the limit is reached.\n   */\n  static async insistForText(\n    name: string,\n    question: string,\n    test: (res: string) => boolean,\n    mask: string | undefined = undefined,\n    initial?: string,\n    defaultConfirmation = false,\n    limit = -1\n  ): Promise<string> {\n    const log = UserInput.logger.for(this.insistForText);\n    log.verbose(\n      `Insisting for text input: undefined, question: ${question}, test: ${test.toString()}, mask: ${mask}, initial: ${initial}, defaultConfirmation: ${defaultConfirmation}, limit: ${limit}`\n    );\n    const userInput = new UserInput(name).setMessage(question);\n\n    if (mask) userInput.setMask(mask);\n    if (typeof initial === \"string\") userInput.setInitial(initial);\n    return (await this.insist(\n      userInput,\n      test as (res: string | number) => boolean,\n      defaultConfirmation,\n      limit\n    )) as string;\n  }\n  /**\n   * @description Repeatedly asks for number input until a valid response is given or the limit is reached.\n   * @summary This method insists on getting a valid number input from the user, allowing for a specified number of attempts.\n   *\n   * @param name - The name of the prompt, used as the key in the returned answers object.\n   * @param question - The message displayed to the user.\n   * @param test - A function to validate the user's input.\n   * @param min - The minimum allowed value (optional).\n   * @param max - The maximum allowed value (optional).\n   * @param initial - The initial value presented to the user (optional).\n   * @param defaultConfirmation\n   * @param limit - The maximum number of attempts allowed (default is -1, meaning unlimited).\n   * @return A Promise that resolves to the valid input or undefined if the limit is reached.\n   */\n  static async insistForNumber(\n    name: string,\n    question: string,\n    test: (res: number) => boolean,\n    min?: number,\n    max?: number,\n    initial?: number,\n    defaultConfirmation = false,\n    limit = -1\n  ): Promise<number> {\n    const log = UserInput.logger.for(this.insistForNumber);\n    log.verbose(\n      `Insisting for number input: undefined, question: ${question}, test: ${test.toString()}, min: ${min}, max: ${max}, initial: ${initial}, defaultConfirmation: ${defaultConfirmation}, limit: ${limit}`\n    );\n    const userInput = new UserInput(name)\n      .setMessage(question)\n      .setType(\"number\");\n\n    if (typeof min === \"number\") userInput.setMin(min);\n\n    if (typeof max === \"number\") userInput.setMax(max);\n\n    if (typeof initial === \"number\") userInput.setInitial(initial);\n    return (await this.insist(\n      userInput,\n      test as (res: string | number) => boolean,\n      defaultConfirmation,\n      limit\n    )) as number;\n  }\n\n  /**\n   * @description Parses command-line arguments based on the provided options.\n   * @summary Uses Node.js's util.parseArgs to parse command-line arguments and return the result.\n   * @param options - Configuration options for parsing arguments.\n   * @return An object containing the parsed arguments.\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as Caller\n   *   participant P as parseArgs method\n   *   participant U as util.parseArgs\n   *   C->>P: Call with options\n   *   P->>P: Prepare args object\n   *   P->>U: Call parseArgs with prepared args\n   *   U->>P: Return parsed result\n   *   P-->>C: Return ParseArgsResult\n   */\n  static parseArgs(options: ParseArgsOptionsConfig): ParseArgsResult {\n    const log = UserInput.logger.for(this.parseArgs);\n    const args: ParseArgsConfig = {\n      args: process.argv.slice(2),\n      options: options,\n    };\n    log.debug(`Parsing arguments: ${JSON.stringify(args, null, 2)}`);\n    try {\n      return parseArgs(args);\n    } catch (error: unknown) {\n      log.debug(\n        `Error while parsing arguments:\\n${JSON.stringify(args, null, 2)}\\n | options\\n${JSON.stringify(options, null, 2)}\\n | ${error}`\n      );\n      throw new Error(`Error while parsing arguments: ${error}`);\n    }\n  }\n}\n"]}