@topcli/prompts 2.4.0 → 3.0.0

package/dist/index.js

@@ -1,16 +1,36 @@
-// src/prompts/question.ts
-import { EOL as EOL2 } from "node:os";
-import { styleText as styleText2 } from "node:util";
+// src/index.ts
+import { once } from "events";
 
-// src/prompts/abstract.ts
-import { EOL } from "node:os";
-import readline from "node:readline";
-import { Writable } from "node:stream";
-import EventEmitter from "node:events";
-import { stripVTControlCharacters } from "node:util";
+// src/validators.ts
+function required() {
+  return {
+    validate: (input) => {
+      const isValid2 = Array.isArray(input) ? input.length > 0 : Boolean(input);
+      return isValid2 ? null : { isValid: isValid2, error: "required" };
+    }
+  };
+}
+function isValid(result) {
+  if (typeof result === "object") {
+    return result?.isValid !== false;
+  }
+  if (typeof result === "string") {
+    return result.length === 0;
+  }
+  return true;
+}
+function isValidTransformation(result) {
+  return typeof result === "object" && result.isValid === true;
+}
+function resultError(result) {
+  if (typeof result === "object") {
+    return result.error;
+  }
+  return result;
+}
 
 // src/prompt-agent.ts
-var kPrivateInstancier = Symbol("instancier");
+var kPrivateInstancier = /* @__PURE__ */ Symbol("instancier");
 var PromptAgent = class _PromptAgent {
   /**
    * The prompts answers queue.
@@ -52,6 +72,62 @@ var PromptAgent = class _PromptAgent {
   }
 };
 
+// src/transformers.ts
+function number() {
+  return {
+    transform(input) {
+      if (input.trim() === "") {
+        return { isValid: false, error: "not a number" };
+      }
+      const parsed = Number(input.replace(",", "."));
+      if (Number.isNaN(parsed)) {
+        return { isValid: false, error: "not a number" };
+      }
+      return { isValid: true, transformed: parsed };
+    }
+  };
+}
+function integer() {
+  return {
+    transform(input) {
+      if (input.trim() === "") {
+        return { isValid: false, error: "not an integer" };
+      }
+      const parsed = Number(input);
+      if (Number.isNaN(parsed) || !Number.isInteger(parsed)) {
+        return { isValid: false, error: "not an integer" };
+      }
+      return { isValid: true, transformed: parsed };
+    }
+  };
+}
+function url() {
+  return {
+    transform(input) {
+      try {
+        return { isValid: true, transformed: new URL(input) };
+      } catch {
+        try {
+          const parsed = new URL(`https://${input}`);
+          if (!parsed.hostname.includes(".") && parsed.hostname !== "localhost") {
+            return { isValid: false, error: "invalid URL" };
+          }
+          return { isValid: true, transformed: parsed };
+        } catch {
+          return { isValid: false, error: "invalid URL" };
+        }
+      }
+    }
+  };
+}
+
+// src/prompts/abstract.ts
+import { EOL } from "os";
+import readline from "readline";
+import { Writable } from "stream";
+import EventEmitter from "events";
+import { stripVTControlCharacters } from "util";
+
 // src/errors/abort.ts
 var AbortError = class extends Error {
   constructor(message) {
@@ -164,9 +240,13 @@ var AbstractPrompt = class _AbstractPrompt extends EventEmitter {
   }
 };
 
+// src/prompts/question.ts
+import { EOL as EOL2 } from "os";
+import { styleText as styleText2 } from "util";
+
 // src/utils.ts
-import process2 from "node:process";
-import { stripVTControlCharacters as stripVTControlCharacters2 } from "node:util";
+import process2 from "process";
+import { stripVTControlCharacters as stripVTControlCharacters2 } from "util";
 var kLenSegmenter = new Intl.Segmenter();
 function isUnicodeSupported() {
   if (process2.platform !== "win32") {
@@ -188,7 +268,7 @@ function stringLength(string) {
 }
 
 // src/constants.ts
-import { styleText } from "node:util";
+import { styleText } from "util";
 var kMainSymbols = {
   tick: "\u2714",
   cross: "\u2716",
@@ -221,31 +301,7 @@ var SYMBOLS = {
   Active: styleText("cyan", kSymbols.active),
   Inactive: styleText("gray", kSymbols.inactive)
 };
-
-// src/validators.ts
-function required() {
-  return {
-    validate: (input) => {
-      const isValid2 = Array.isArray(input) ? input.length > 0 : Boolean(input);
-      return isValid2 ? null : { isValid: isValid2, error: "required" };
-    }
-  };
-}
-function isValid(result) {
-  if (typeof result === "object") {
-    return result?.isValid !== false;
-  }
-  if (typeof result === "string") {
-    return result.length > 0;
-  }
-  return true;
-}
-function resultError(result) {
-  if (typeof result === "object") {
-    return result.error;
-  }
-  return result;
-}
+var VALIDATION_SPINNER_INTERVAL = 300;
 
 // src/prompts/question.ts
 var QuestionPrompt = class extends AbstractPrompt {
@@ -255,22 +311,29 @@ var QuestionPrompt = class extends AbstractPrompt {
   answer;
   answerBuffer;
   #validators;
+  #transformer;
+  #transformedAnswer;
   #secure;
   #securePlaceholder = null;
   constructor(options) {
     const {
       defaultValue,
-      validators = [],
+      validators: validators2 = [],
+      transformer,
       secure = false,
       ...baseOptions
     } = options;
     super({ ...baseOptions });
+    if (validators2.length > 0 && transformer !== void 0) {
+      throw new Error("validators and transformer are mutually exclusive");
+    }
     if (defaultValue && typeof defaultValue !== "string") {
       throw new TypeError("defaultValue must be a string");
     }
     this.defaultValue = defaultValue;
     this.tip = this.defaultValue ? ` (${this.defaultValue})` : "";
-    this.#validators = validators;
+    this.#validators = validators2;
+    this.#transformer = transformer;
     if (typeof secure === "object") {
       this.#secure = true;
       this.#securePlaceholder = secure.placeholder;
@@ -280,18 +343,18 @@ var QuestionPrompt = class extends AbstractPrompt {
     this.questionSuffixError = "";
   }
   #question() {
-    return new Promise((resolve) => {
-      const questionQuery = this.#getQuestionQuery();
-      this.history.push(questionQuery);
-      this.rl.question(questionQuery, (answer) => {
-        this.history.push(questionQuery + answer);
-        this.reset();
-        resolve(answer);
-      });
-      if (this.#securePlaceholder !== null) {
-        this.transformer = (input) => Buffer.from(this.#securePlaceholder.repeat(input.length), "utf-8");
-      }
+    const { resolve, promise } = Promise.withResolvers();
+    const questionQuery = this.#getQuestionQuery();
+    this.history.push(questionQuery);
+    this.rl.question(questionQuery, (answer) => {
+      this.history.push(questionQuery + answer);
+      this.reset();
+      resolve(answer);
     });
+    if (this.#securePlaceholder !== null) {
+      this.transformer = (input) => Buffer.from(this.#securePlaceholder.repeat(input.length), "utf-8");
+    }
+    return promise;
   }
   #getQuestionQuery() {
     return `${styleText2("bold", `${SYMBOLS.QuestionMark} ${this.message}${this.tip}`)} ${this.questionSuffixError}`;
@@ -310,14 +373,68 @@ var QuestionPrompt = class extends AbstractPrompt {
     );
     this.write(`${prefix} ${styleText2("bold", this.message)} ${SYMBOLS.Pointer} ${stylizedAnswer}${EOL2}`);
   }
-  #onQuestionAnswer() {
+  #getValidatingQuery(dotCount) {
+    const question2 = styleText2("bold", `${SYMBOLS.QuestionMark} ${this.message}${this.tip}`);
+    const hint = styleText2("yellow", `[validating${".".repeat(dotCount)}]`);
+    return `${question2} ${hint}${EOL2}`;
+  }
+  async #runTransformer() {
+    const result = this.#transformer.transform(this.answer);
+    if (result instanceof Promise) {
+      let dotCount = 1;
+      this.write(this.#getValidatingQuery(dotCount));
+      const spinnerInterval = setInterval(() => {
+        dotCount = dotCount % 3 + 1;
+        this.clearLastLine();
+        this.write(this.#getValidatingQuery(dotCount));
+      }, VALIDATION_SPINNER_INTERVAL);
+      try {
+        return await result;
+      } finally {
+        clearInterval(spinnerInterval);
+        this.clearLastLine();
+      }
+    }
+    return result;
+  }
+  async #onQuestionAnswer() {
     const questionLineCount = Math.ceil(
       stringLength(this.#getQuestionQuery() + this.answer) / this.stdout.columns
     );
     this.stdout.moveCursor(-this.stdout.columns, -questionLineCount);
     this.stdout.clearScreenDown();
+    if (this.#transformer) {
+      const result = await this.#runTransformer();
+      if (isValidTransformation(result) === false) {
+        this.#setQuestionSuffixError(resultError(result));
+        this.answerBuffer = this.#question();
+        return;
+      }
+      this.#transformedAnswer = result.transformed;
+      this.answerBuffer = void 0;
+      this.#writeAnswer();
+      return;
+    }
     for (const validator of this.#validators) {
-      const validationResult = validator.validate(this.answer);
+      let validationResult;
+      const result = validator.validate(this.answer);
+      if (result instanceof Promise) {
+        let dotCount = 1;
+        this.write(this.#getValidatingQuery(dotCount));
+        const spinnerInterval = setInterval(() => {
+          dotCount = dotCount % 3 + 1;
+          this.clearLastLine();
+          this.write(this.#getValidatingQuery(dotCount));
+        }, VALIDATION_SPINNER_INTERVAL);
+        try {
+          validationResult = await result;
+        } finally {
+          clearInterval(spinnerInterval);
+          this.clearLastLine();
+        }
+      } else {
+        validationResult = result;
+      }
       if (isValid(validationResult) === false) {
         this.#setQuestionSuffixError(resultError(validationResult));
         this.answerBuffer = this.#question();
@@ -327,40 +444,50 @@ var QuestionPrompt = class extends AbstractPrompt {
     this.answerBuffer = void 0;
     this.#writeAnswer();
   }
-  async question() {
+  async listen() {
     if (this.skip) {
       this.destroy();
+      if (this.#transformer) {
+        const rawValue = this.defaultValue ?? "";
+        const result = await this.#transformer.transform(rawValue);
+        if (isValidTransformation(result) === false) {
+          throw new Error(`Transformer failed for default value "${rawValue}": ${resultError(result)}`);
+        }
+        return result.transformed;
+      }
       return this.defaultValue ?? "";
     }
-    return new Promise(async (resolve, reject) => {
-      this.answer = this.agent.nextAnswers.shift();
-      if (this.answer !== void 0) {
-        this.#writeAnswer();
-        this.destroy();
-        resolve(this.answer);
-        return;
-      }
-      this.once("error", (error) => {
-        reject(error);
-      });
-      this.answer = await this.#question();
-      if (this.answer === "" && this.defaultValue) {
-        this.answer = this.defaultValue;
-      }
-      this.#onQuestionAnswer();
-      while (this.answerBuffer !== void 0) {
-        this.answer = await this.answerBuffer;
-        this.#onQuestionAnswer();
-      }
+    const agentAnswer = this.agent.nextAnswers.shift();
+    if (agentAnswer !== void 0) {
+      this.answer = agentAnswer;
+      this.#writeAnswer();
       this.destroy();
-      resolve(this.answer);
-    });
+      if (this.#transformer) {
+        const result = await this.#transformer.transform(agentAnswer);
+        if (isValidTransformation(result) === false) {
+          throw new Error(`(PromptAgent) transformer failed for answer "${agentAnswer}": ${resultError(result)}`);
+        }
+        return result.transformed;
+      }
+      return this.answer;
+    }
+    this.answer = await this.#question();
+    if (this.answer === "" && this.defaultValue) {
+      this.answer = this.defaultValue;
+    }
+    await this.#onQuestionAnswer();
+    while (this.answerBuffer !== void 0) {
+      this.answer = await this.answerBuffer;
+      await this.#onQuestionAnswer();
+    }
+    this.destroy();
+    return this.#transformedAnswer ?? this.answer;
   }
 };
 
 // src/prompts/confirm.ts
-import { EOL as EOL3 } from "node:os";
-import { styleText as styleText3 } from "node:util";
+import { EOL as EOL3 } from "os";
+import { styleText as styleText3 } from "util";
 var kToggleKeys = /* @__PURE__ */ new Set([
   "left",
   "right",
@@ -397,16 +524,6 @@ var ConfirmPrompt = class extends AbstractPrompt {
   #render() {
     this.write(this.#getQuestionQuery());
   }
-  #question() {
-    return new Promise((resolve) => {
-      const questionQuery = this.#getQuestionQuery();
-      this.write(questionQuery);
-      this.#boundKeyPressEvent = this.#onKeypress.bind(this, resolve);
-      this.stdin.on("keypress", this.#boundKeyPressEvent);
-      this.#boundExitEvent = this.#onProcessExit.bind(this);
-      process.once("exit", this.#boundExitEvent);
-    });
-  }
   #onKeypress(resolve, _value, key) {
     this.stdout.moveCursor(
       -this.stdout.columns,
@@ -449,46 +566,48 @@ var ConfirmPrompt = class extends AbstractPrompt {
     this.stdout.clearScreenDown();
     this.write(`${this.selectedValue ? SYMBOLS.Tick : SYMBOLS.Cross} ${styleText3("bold", this.message)}${EOL3}`);
   }
-  async confirm() {
+  async listen() {
     if (this.skip) {
       this.destroy();
       return this.initial;
     }
-    return new Promise(async (resolve, reject) => {
-      const answer = this.agent.nextAnswers.shift();
-      if (answer !== void 0) {
-        this.selectedValue = answer;
-        this.#onQuestionAnswer();
-        this.destroy();
-        resolve(answer);
-        return;
-      }
-      this.once("error", (error) => {
-        reject(error);
-      });
-      this.write(SYMBOLS.HideCursor);
-      try {
-        await this.#question();
-        this.#onQuestionAnswer();
-        resolve(this.selectedValue);
-      } finally {
-        this.write(SYMBOLS.ShowCursor);
-        this.#onProcessExit();
-        process.off("exit", this.#boundExitEvent);
-        this.destroy();
-      }
-    });
+    const answer = this.agent.nextAnswers.shift();
+    if (answer !== void 0) {
+      this.selectedValue = answer;
+      this.#onQuestionAnswer();
+      this.destroy();
+      return answer;
+    }
+    this.write(SYMBOLS.HideCursor);
+    try {
+      const { resolve, promise } = Promise.withResolvers();
+      const questionQuery = this.#getQuestionQuery();
+      this.write(questionQuery);
+      this.#boundKeyPressEvent = this.#onKeypress.bind(this, resolve);
+      this.stdin.on("keypress", this.#boundKeyPressEvent);
+      this.#boundExitEvent = this.#onProcessExit.bind(this);
+      process.once("exit", this.#boundExitEvent);
+      await promise;
+      this.#onQuestionAnswer();
+    } finally {
+      this.write(SYMBOLS.ShowCursor);
+      this.#onProcessExit();
+      process.off("exit", this.#boundExitEvent);
+      this.destroy();
+    }
+    return this.selectedValue;
   }
 };
 
 // src/prompts/select.ts
-import { EOL as EOL4 } from "node:os";
-import { styleText as styleText4 } from "node:util";
+import { EOL as EOL4 } from "os";
+import { styleText as styleText4 } from "util";
 var kRequiredChoiceProperties = ["label", "value"];
 var SelectPrompt = class extends AbstractPrompt {
   #boundExitEvent = () => void 0;
   #boundKeyPressEvent = () => void 0;
   #validators;
+  #isValidating = false;
   activeIndex = 0;
   questionMessage;
   autocompleteValue = "";
@@ -529,7 +648,7 @@ var SelectPrompt = class extends AbstractPrompt {
   constructor(options) {
     const {
       choices,
-      validators = [],
+      validators: validators2 = [],
       ...baseOptions
     } = options;
     super({ ...baseOptions });
@@ -538,7 +657,7 @@ var SelectPrompt = class extends AbstractPrompt {
       this.destroy();
       throw new TypeError("Missing required param: choices");
     }
-    this.#validators = validators;
+    this.#validators = validators2;
     for (const choice of choices) {
       if (typeof choice === "string") {
         continue;
@@ -594,6 +713,48 @@ var SelectPrompt = class extends AbstractPrompt {
       this.write(str);
     }
   }
+  async #handleReturn(resolve, render) {
+    this.#isValidating = true;
+    try {
+      const choice = this.filteredChoices[this.activeIndex] || "";
+      const label = typeof choice === "string" ? choice : choice.label;
+      const value = typeof choice === "string" ? choice : choice.value;
+      for (const validator of this.#validators) {
+        let validationResult;
+        const result = validator.validate(value);
+        if (result instanceof Promise) {
+          let dotCount = 1;
+          render({ validating: `validating${".".repeat(dotCount)}` });
+          const spinnerInterval = setInterval(() => {
+            dotCount = dotCount % 3 + 1;
+            render({ validating: `validating${".".repeat(dotCount)}` });
+          }, VALIDATION_SPINNER_INTERVAL);
+          try {
+            validationResult = await result;
+          } finally {
+            clearInterval(spinnerInterval);
+          }
+        } else {
+          validationResult = result;
+        }
+        if (isValid(validationResult) === false) {
+          render({ error: resultError(validationResult) });
+          return;
+        }
+      }
+      render({ clearRender: true });
+      if (!this.options.ignoreValues?.includes(value)) {
+        this.#showAnsweredQuestion(label);
+      }
+      this.write(SYMBOLS.ShowCursor);
+      this.destroy();
+      this.#onProcessExit();
+      process.off("exit", this.#boundExitEvent);
+      resolve(value);
+    } finally {
+      this.#isValidating = false;
+    }
+  }
   #showAnsweredQuestion(label) {
     const symbolPrefix = label === "" ? SYMBOLS.Cross : SYMBOLS.Tick;
     const prefix = `${symbolPrefix} ${styleText4("bold", this.message)} ${SYMBOLS.Pointer}`;
@@ -608,6 +769,9 @@ var SelectPrompt = class extends AbstractPrompt {
   }
   #onKeypress(...args) {
     const [resolve, render, , key] = args;
+    if (this.#isValidating) {
+      return;
+    }
     if (key.name === "up") {
       this.activeIndex = this.activeIndex === 0 ? this.filteredChoices.length - 1 : this.activeIndex - 1;
       render();
@@ -615,25 +779,7 @@ var SelectPrompt = class extends AbstractPrompt {
       this.activeIndex = this.activeIndex === this.filteredChoices.length - 1 ? 0 : this.activeIndex + 1;
       render();
     } else if (key.name === "return") {
-      const choice = this.filteredChoices[this.activeIndex] || "";
-      const label = typeof choice === "string" ? choice : choice.label;
-      const value = typeof choice === "string" ? choice : choice.value;
-      for (const validator of this.#validators) {
-        const validationResult = validator.validate(value);
-        if (isValid(validationResult) === false) {
-          render({ error: resultError(validationResult) });
-          return;
-        }
-      }
-      render({ clearRender: true });
-      if (!this.options.ignoreValues?.includes(value)) {
-        this.#showAnsweredQuestion(label);
-      }
-      this.write(SYMBOLS.ShowCursor);
-      this.destroy();
-      this.#onProcessExit();
-      process.off("exit", this.#boundExitEvent);
-      resolve(value);
+      void this.#handleReturn(resolve, render);
     } else {
       if (!key.ctrl && this.options.autocomplete) {
         this.activeIndex = 0;
@@ -646,89 +792,84 @@ var SelectPrompt = class extends AbstractPrompt {
       render();
     }
   }
-  async select() {
+  async listen() {
     if (this.skip) {
       this.destroy();
-      const answer = this.options.choices[0];
-      return typeof answer === "string" ? answer : answer.value;
+      const answer2 = this.options.choices[0];
+      return typeof answer2 === "string" ? answer2 : answer2.value;
     }
-    return new Promise((resolve, reject) => {
-      const answer = this.agent.nextAnswers.shift();
-      if (answer !== void 0) {
-        this.#showAnsweredQuestion(answer);
-        this.destroy();
-        resolve(answer);
-        return;
-      }
-      this.once("error", (error) => {
-        reject(error);
-      });
-      this.write(SYMBOLS.HideCursor);
-      this.#showQuestion();
-      const render = (options = {}) => {
-        const {
-          initialRender = false,
-          clearRender = false,
-          error = null
-        } = options;
-        if (!initialRender) {
-          let linesToClear = this.lastRender.endIndex - this.lastRender.startIndex;
-          while (linesToClear > 0) {
-            this.clearLastLine();
-            linesToClear--;
-          }
-          if (this.options.autocomplete) {
-            let linesToClear2 = Math.ceil(
-              stringLength(`${SYMBOLS.Pointer} ${this.autocompleteValue}`) / this.stdout.columns
-            );
-            while (linesToClear2 > 0) {
-              this.clearLastLine();
-              linesToClear2--;
-            }
-          }
+    const answer = this.agent.nextAnswers.shift();
+    if (answer !== void 0) {
+      this.#showAnsweredQuestion(answer);
+      this.destroy();
+      return answer;
+    }
+    this.transformer = () => null;
+    this.write(SYMBOLS.HideCursor);
+    this.#showQuestion();
+    const render = (options = {}) => {
+      const {
+        initialRender = false,
+        clearRender = false,
+        error = null,
+        validating = null
+      } = options;
+      if (!initialRender) {
+        let linesToClear = this.lastRender.endIndex - this.lastRender.startIndex;
+        while (linesToClear > 0) {
+          this.clearLastLine();
+          linesToClear--;
         }
-        if (clearRender) {
-          const questionLineCount = Math.ceil(
-            stringLength(this.questionMessage) / this.stdout.columns
+        if (this.options.autocomplete) {
+          let linesToClear2 = Math.ceil(
+            stringLength(`${SYMBOLS.Pointer} ${this.autocompleteValue}`) / this.stdout.columns
           );
-          this.stdout.moveCursor(-this.stdout.columns, -(1 + questionLineCount));
-          this.stdout.clearScreenDown();
-          return;
-        }
-        if (error) {
-          const linesToClear = Math.ceil(stringLength(this.questionMessage) / this.stdout.columns) + 1;
-          this.stdout.moveCursor(0, -linesToClear);
-          this.stdout.clearScreenDown();
-          this.#showQuestion(error);
+          while (linesToClear2 > 0) {
+            this.clearLastLine();
+            linesToClear2--;
+          }
         }
-        this.#showChoices();
-      };
-      render({ initialRender: true });
-      this.#boundKeyPressEvent = this.#onKeypress.bind(this, resolve, render);
-      this.stdin.on("keypress", this.#boundKeyPressEvent);
-      this.#boundExitEvent = this.#onProcessExit.bind(this);
-      process.once("exit", this.#boundExitEvent);
-    });
+      }
+      if (clearRender) {
+        this.clearLastLine();
+        return;
+      }
+      if (error || validating) {
+        this.clearLastLine();
+        this.#showQuestion(error, validating);
+      }
+      this.#showChoices();
+    };
+    render({ initialRender: true });
+    this.#boundExitEvent = this.#onProcessExit.bind(this);
+    process.once("exit", this.#boundExitEvent);
+    const { resolve, promise } = Promise.withResolvers();
+    this.#boundKeyPressEvent = this.#onKeypress.bind(this, resolve, render);
+    this.stdin.on("keypress", this.#boundKeyPressEvent);
+    return promise;
   }
-  #showQuestion(error = null) {
+  #showQuestion(error = null, validating = null) {
     let hint = "";
-    if (error) {
-      hint = ` ${hint.length > 0 ? " " : ""}${styleText4(["red", "bold"], `[${error}]`)}`;
+    if (validating) {
+      hint = styleText4("yellow", `[${validating}]`);
+    } else if (error) {
+      hint += `${hint.length > 0 ? " " : ""}${styleText4(["red", "bold"], `[${error}]`)}`;
     }
-    this.questionMessage = `${SYMBOLS.QuestionMark} ${styleText4("bold", this.message)}${hint}`;
+    this.questionMessage = `${SYMBOLS.QuestionMark} ${styleText4("bold", this.message)}${hint.length > 0 ? ` ${hint}` : ""}`;
     this.write(`${this.questionMessage}${EOL4}`);
   }
 };
 
 // src/prompts/multiselect.ts
-import { EOL as EOL5 } from "node:os";
-import { styleText as styleText5 } from "node:util";
+import { EOL as EOL5 } from "os";
+import { styleText as styleText5 } from "util";
 var kRequiredChoiceProperties2 = ["label", "value"];
 var MultiselectPrompt = class extends AbstractPrompt {
   #boundExitEvent = () => void 0;
   #boundKeyPressEvent = () => void 0;
   #validators;
   #showHint;
+  #isValidating = false;
   activeIndex = 0;
   selectedIndexes = /* @__PURE__ */ new Set();
   questionMessage;
@@ -771,7 +912,7 @@ var MultiselectPrompt = class extends AbstractPrompt {
     const {
       choices,
       preSelectedChoices = [],
-      validators = [],
+      validators: validators2 = [],
       showHint = true,
       ...baseOptions
     } = options;
@@ -781,7 +922,7 @@ var MultiselectPrompt = class extends AbstractPrompt {
       this.destroy();
       throw new TypeError("Missing required param: choices");
     }
-    this.#validators = validators;
+    this.#validators = validators2;
     this.#showHint = showHint;
     for (const choice of choices) {
       if (typeof choice === "string") {
@@ -852,6 +993,44 @@ var MultiselectPrompt = class extends AbstractPrompt {
       this.write(str);
     }
   }
+  async #handleReturn(resolve, render) {
+    this.#isValidating = true;
+    try {
+      const { values, labels } = this.#selectedChoices();
+      for (const validator of this.#validators) {
+        let validationResult;
+        const result = validator.validate(values);
+        if (result instanceof Promise) {
+          let dotCount = 1;
+          render({ validating: `validating${".".repeat(dotCount)}` });
+          const spinnerInterval = setInterval(() => {
+            dotCount = dotCount % 3 + 1;
+            render({ validating: `validating${".".repeat(dotCount)}` });
+          }, VALIDATION_SPINNER_INTERVAL);
+          try {
+            validationResult = await result;
+          } finally {
+            clearInterval(spinnerInterval);
+          }
+        } else {
+          validationResult = result;
+        }
+        if (isValid(validationResult) === false) {
+          render({ error: resultError(validationResult) });
+          return;
+        }
+      }
+      render({ clearRender: true });
+      this.#showAnsweredQuestion(labels.join(", "));
+      this.write(SYMBOLS.ShowCursor);
+      this.destroy();
+      this.#onProcessExit();
+      process.off("exit", this.#boundExitEvent);
+      resolve(values);
+    } finally {
+      this.#isValidating = false;
+    }
+  }
   #showAnsweredQuestion(choices, isAgentAnswer = false) {
     const prefixSymbol = this.selectedIndexes.size === 0 && !isAgentAnswer ? SYMBOLS.Cross : SYMBOLS.Tick;
     const prefix = `${prefixSymbol} ${styleText5("bold", this.message)} ${SYMBOLS.Pointer}`;
@@ -885,6 +1064,9 @@ var MultiselectPrompt = class extends AbstractPrompt {
   }
   #onKeypress(...args) {
     const [resolve, render, , key] = args;
+    if (this.#isValidating) {
+      return;
+    }
     if (key.name === "up") {
       this.activeIndex = this.activeIndex === 0 ? this.filteredChoices.length - 1 : this.activeIndex - 1;
       render();
@@ -901,21 +1083,7 @@ var MultiselectPrompt = class extends AbstractPrompt {
       this.selectedIndexes = new Set([...this.selectedIndexes].filter((index) => index !== this.activeIndex));
       render();
     } else if (key.name === "return") {
-      const { values, labels } = this.#selectedChoices();
-      for (const validator of this.#validators) {
-        const validationResult = validator.validate(values);
-        if (isValid(validationResult) === false) {
-          render({ error: resultError(validationResult) });
-          return;
-        }
-      }
-      render({ clearRender: true });
-      this.#showAnsweredQuestion(labels.join(", "));
-      this.write(SYMBOLS.ShowCursor);
-      this.destroy();
-      this.#onProcessExit();
-      process.off("exit", this.#boundExitEvent);
-      resolve(values);
+      void this.#handleReturn(resolve, render);
     } else {
       if (!key.ctrl && this.options.autocomplete) {
         this.selectedIndexes.clear();
@@ -929,78 +1097,72 @@ var MultiselectPrompt = class extends AbstractPrompt {
       render();
     }
   }
-  async multiselect() {
+  async listen() {
     if (this.skip) {
       this.destroy();
       const { values } = this.#selectedChoices();
       return values;
     }
-    return new Promise((resolve, reject) => {
-      const answer = this.agent.nextAnswers.shift();
-      if (answer !== void 0) {
-        const formatedAnser = Array.isArray(answer) ? answer.join(", ") : answer;
-        this.#showAnsweredQuestion(formatedAnser, true);
-        this.destroy();
-        resolve(Array.isArray(answer) ? answer : [answer]);
-        return;
-      }
-      this.once("error", (error) => {
-        reject(error);
-      });
-      this.write(SYMBOLS.HideCursor);
-      this.#showQuestion();
-      const render = (options = {}) => {
-        const {
-          initialRender = false,
-          clearRender = false,
-          error = null
-        } = options;
-        if (!initialRender) {
-          let linesToClear = this.lastRender.endIndex - this.lastRender.startIndex;
-          while (linesToClear > 0) {
-            this.clearLastLine();
-            linesToClear--;
-          }
-          if (this.options.autocomplete) {
-            let linesToClear2 = Math.ceil(
-              stringLength(`${SYMBOLS.Pointer} ${this.autocompleteValue}`) / this.stdout.columns
-            );
-            while (linesToClear2 > 0) {
-              this.clearLastLine();
-              linesToClear2--;
-            }
-          }
+    const answer = this.agent.nextAnswers.shift();
+    if (answer !== void 0) {
+      const formatedAnser = Array.isArray(answer) ? answer.join(", ") : answer;
+      this.#showAnsweredQuestion(formatedAnser, true);
+      this.destroy();
+      return Array.isArray(answer) ? answer : [answer];
+    }
+    this.transformer = () => null;
+    this.write(SYMBOLS.HideCursor);
+    this.#showQuestion();
+    const render = (options = {}) => {
+      const {
+        initialRender = false,
+        clearRender = false,
+        error = null,
+        validating = null
+      } = options;
+      if (!initialRender) {
+        let linesToClear = this.lastRender.endIndex - this.lastRender.startIndex;
+        while (linesToClear > 0) {
+          this.clearLastLine();
+          linesToClear--;
         }
-        if (clearRender) {
-          const questionLineCount = Math.ceil(
-            stringLength(this.questionMessage) / this.stdout.columns
+        if (this.options.autocomplete) {
+          let linesToClear2 = Math.ceil(
+            stringLength(`${SYMBOLS.Pointer} ${this.autocompleteValue}`) / this.stdout.columns
           );
-          this.stdout.moveCursor(-this.stdout.columns, -(1 + questionLineCount));
-          this.stdout.clearScreenDown();
-          return;
-        }
-        if (error) {
-          const linesToClear = Math.ceil(stringLength(this.questionMessage) / this.stdout.columns) + 1;
-          this.stdout.moveCursor(0, -linesToClear);
-          this.stdout.clearScreenDown();
-          this.#showQuestion(error);
+          while (linesToClear2 > 0) {
+            this.clearLastLine();
+            linesToClear2--;
+          }
         }
-        this.#showChoices();
-      };
-      render({ initialRender: true });
-      this.#boundKeyPressEvent = this.#onKeypress.bind(this, resolve, render);
-      this.stdin.on("keypress", this.#boundKeyPressEvent);
-      this.#boundExitEvent = this.#onProcessExit.bind(this);
-      process.once("exit", this.#boundExitEvent);
-    });
+      }
+      if (clearRender) {
+        this.clearLastLine();
+        return;
+      }
+      if (error || validating) {
+        this.clearLastLine();
+        this.#showQuestion(error, validating);
+      }
+      this.#showChoices();
+    };
+    render({ initialRender: true });
+    this.#boundExitEvent = this.#onProcessExit.bind(this);
+    process.once("exit", this.#boundExitEvent);
+    const { promise, resolve } = Promise.withResolvers();
+    this.#boundKeyPressEvent = this.#onKeypress.bind(this, resolve, render);
+    this.stdin.on("keypress", this.#boundKeyPressEvent);
+    return promise;
   }
-  #showQuestion(error = null) {
+  #showQuestion(error = null, validating = null) {
     let hint = this.#showHint ? styleText5(
       "gray",
       // eslint-disable-next-line @stylistic/max-len
       `(Press ${styleText5("bold", "<Ctrl+A>")} to toggle all, ${styleText5("bold", "<Left/Right>")} to toggle, ${styleText5("bold", "<Return>")} to submit)`
     ) : "";
-    if (error) {
+    if (validating) {
+      hint += `${hint.length > 0 ? " " : ""}${styleText5("yellow", `[${validating}]`)}`;
+    } else if (error) {
       hint += `${hint.length > 0 ? " " : ""}${styleText5(["red", "bold"], `[${error}]`)}`;
     }
     this.questionMessage = `${SYMBOLS.QuestionMark} ${styleText5("bold", this.message)}${hint.length > 0 ? ` ${hint}` : ""}`;
@@ -1008,27 +1170,102 @@ var MultiselectPrompt = class extends AbstractPrompt {
   }
 };
 
-// index.ts
-function question(message, options = {}) {
-  return new QuestionPrompt({ ...options, message }).question();
+// src/index.ts
+async function question(message, options = {}) {
+  const prompt = new QuestionPrompt(
+    { ...options, message }
+  );
+  const onErrorSignal = new AbortController();
+  const onError = once(
+    prompt,
+    "error",
+    { signal: onErrorSignal.signal }
+  );
+  const result = await Promise.race([
+    prompt.listen(),
+    onError
+  ]);
+  if (isAbortError(result)) {
+    prompt.destroy();
+    throw result[0];
+  }
+  onErrorSignal.abort();
+  return result;
+}
+async function select(message, options) {
+  const prompt = new SelectPrompt(
+    { ...options, message }
+  );
+  const onErrorSignal = new AbortController();
+  const onError = once(
+    prompt,
+    "error",
+    { signal: onErrorSignal.signal }
+  );
+  const result = await Promise.race([
+    prompt.listen(),
+    onError
+  ]);
+  if (isAbortError(result)) {
+    prompt.destroy();
+    throw result[0];
+  }
+  onErrorSignal.abort();
+  return result;
 }
-function select(message, options) {
-  const selectPrompt = new SelectPrompt({ ...options, message });
-  return selectPrompt.select();
+async function confirm(message, options = {}) {
+  const prompt = new ConfirmPrompt(
+    { ...options, message }
+  );
+  const onErrorSignal = new AbortController();
+  const onError = once(
+    prompt,
+    "error",
+    { signal: onErrorSignal.signal }
+  );
+  const result = await Promise.race([
+    prompt.listen(),
+    onError
+  ]);
+  if (isAbortError(result)) {
+    prompt.destroy();
+    throw result[0];
+  }
+  onErrorSignal.abort();
+  return result;
 }
-function confirm(message, options = {}) {
-  const confirmPrompt = new ConfirmPrompt({ ...options, message });
-  return confirmPrompt.confirm();
+async function multiselect(message, options) {
+  const prompt = new MultiselectPrompt(
+    { ...options, message }
+  );
+  const onErrorSignal = new AbortController();
+  const onError = once(
+    prompt,
+    "error",
+    { signal: onErrorSignal.signal }
+  );
+  const result = await Promise.race([
+    prompt.listen(),
+    onError
+  ]);
+  if (isAbortError(result)) {
+    prompt.destroy();
+    throw result[0];
+  }
+  onErrorSignal.abort();
+  return result;
 }
-function multiselect(message, options) {
-  const multiselectPrompt = new MultiselectPrompt({ ...options, message });
-  return multiselectPrompt.multiselect();
+function isAbortError(error) {
+  return Array.isArray(error) && error.length > 0 && error[0] instanceof Error;
 }
+var validators = { required };
+var transformers = { number, integer, url };
 export {
   PromptAgent,
   confirm,
   multiselect,
   question,
-  required,
-  select
+  select,
+  transformers,
+  validators
 };