Merge pull request #156 from TopCli/enhance-error-handling

Enhance error handling & remove new Promise

Author: fraxken

src/index.ts

@@ -1,3 +1,6 @@
+// Import Node.js Dependencies
+import { once } from "node:events";
+
 // Import Internal Dependencies
 import {
   required,
@@ -24,41 +27,116 @@ import {
   type ConfirmOptions,
   type MultiselectOptions
 } from "./prompts/index.js";
+import type { AbortError } from "./errors/abort.js";
 
-export function question(
+export async function question(
   message: string,
   options: Omit<QuestionOptions, "message"> = {}
-) {
-  return new QuestionPrompt(
+): Promise<string> {
+  const prompt = new QuestionPrompt(
     { ...options, message }
-  ).question();
+  );
+
+  const onErrorSignal = new AbortController();
+  const onError = once(
+    prompt, "error", { signal: onErrorSignal.signal }
+  ) as Promise<[AbortError]>;
+  const result = await Promise.race([
+    prompt.listen(),
+    onError
+  ]);
+  if (isAbortError(result)) {
+    prompt.destroy();
+
+    throw result[0];
+  }
+  onErrorSignal.abort();
+
+  return result;
 }
 
-export function select<T extends string>(
+export async function select<T extends string>(
   message: string,
   options: Omit<SelectOptions<T>, "message">
-) {
-  return new SelectPrompt<T>(
+): Promise<T> {
+  const prompt = new SelectPrompt<T>(
     { ...options, message }
-  ).select();
+  );
+
+  const onErrorSignal = new AbortController();
+  const onError = once(
+    prompt, "error", { signal: onErrorSignal.signal }
+  ) as Promise<[AbortError]>;
+  const result = await Promise.race([
+    prompt.listen(),
+    onError
+  ]);
+  if (isAbortError(result)) {
+    prompt.destroy();
+
+    throw result[0];
+  }
+  onErrorSignal.abort();
+
+  return result;
 }
 
-export function confirm(
+export async function confirm(
   message: string,
   options: Omit<ConfirmOptions, "message"> = {}
-) {
-  return new ConfirmPrompt(
+): Promise<boolean> {
+  const prompt = new ConfirmPrompt(
     { ...options, message }
-  ).confirm();
+  );
+
+  const onErrorSignal = new AbortController();
+  const onError = once(
+    prompt, "error", { signal: onErrorSignal.signal }
+  ) as Promise<[AbortError]>;
+  const result = await Promise.race([
+    prompt.listen(),
+    onError
+  ]);
+  if (isAbortError(result)) {
+    prompt.destroy();
+
+    throw result[0];
+  }
+  onErrorSignal.abort();
+
+  return result;
 }
 
-export function multiselect<T extends string>(
+export async function multiselect<T extends string>(
   message: string,
   options: Omit<MultiselectOptions<T>, "message">
-) {
-  return new MultiselectPrompt<T>(
+): Promise<T[]> {
+  const prompt = new MultiselectPrompt<T>(
     { ...options, message }
-  ).multiselect();
+  );
+
+  const onErrorSignal = new AbortController();
+  const onError = once(
+    prompt, "error", { signal: onErrorSignal.signal }
+  ) as Promise<[AbortError]>;
+  const result = await Promise.race([
+    prompt.listen(),
+    onError
+  ]);
+  if (isAbortError(result)) {
+    prompt.destroy();
+
+    throw result[0];
+  }
+  onErrorSignal.abort();
+
+  return result;
+}
+
+function isAbortError(
+  error: unknown
+): error is [AbortError] {
+  return Array.isArray(error) && error.length > 0 && error[0] instanceof Error;
 }
 
 export type {

src/prompts/confirm.ts

@@ -5,7 +5,7 @@ import { styleText } from "node:util";
 
 // Import Internal Dependencies
 import { AbstractPrompt, type AbstractPromptOptions } from "./abstract.js";
-import { stringLength } from "../utils.js";
+import { stringLength, withResolvers } from "../utils.js";
 import { SYMBOLS } from "../constants.js";
 
 export interface ConfirmOptions extends AbstractPromptOptions {
@@ -56,21 +56,7 @@ export class ConfirmPrompt extends AbstractPrompt<boolean> {
     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: unknown) => void, _value: any, key: Key) {
+  #onKeypress(resolve: (value: boolean) => void, _value: any, key: Key) {
     this.stdout.moveCursor(
       -this.stdout.columns,
       -Math.floor(stringLength(this.#getQuestionQuery()) / this.stdout.columns)
@@ -123,46 +109,47 @@ export class ConfirmPrompt extends AbstractPrompt<boolean> {
     this.write(`${this.selectedValue ? SYMBOLS.Tick : SYMBOLS.Cross} ${styleText("bold", this.message)}${EOL}`);
   }
 
-  async confirm(): Promise<boolean> {
+  async listen(): Promise<boolean> {
     if (this.skip) {
       this.destroy();
 
       return this.initial;
     }
 
-    // eslint-disable-next-line no-async-promise-executor
-    return new Promise(async(resolve, reject) => {
-      const answer = this.agent.nextAnswers.shift();
-      if (answer !== undefined) {
-        this.selectedValue = answer;
-        this.#onQuestionAnswer();
-        this.destroy();
+    const answer = this.agent.nextAnswers.shift();
+    if (answer !== undefined) {
+      this.selectedValue = answer;
+      this.#onQuestionAnswer();
+      this.destroy();
+
+      return answer;
+    }
+
+    this.write(SYMBOLS.HideCursor);
 
-        resolve(answer);
+    try {
+      const { resolve, promise } = withResolvers<boolean>();
+      const questionQuery = this.#getQuestionQuery();
 
-        return;
-      }
+      this.write(questionQuery);
 
-      this.once("error", (error) => {
-        reject(error);
-      });
+      this.#boundKeyPressEvent = this.#onKeypress.bind(this, resolve);
+      this.stdin.on("keypress", this.#boundKeyPressEvent);
 
-      this.write(SYMBOLS.HideCursor);
+      this.#boundExitEvent = this.#onProcessExit.bind(this);
+      process.once("exit", this.#boundExitEvent);
 
-      try {
-        await this.#question();
-        this.#onQuestionAnswer();
+      this.#onQuestionAnswer();
 
-        resolve(this.selectedValue);
-      }
-      finally {
-        this.write(SYMBOLS.ShowCursor);
+      return promise;
+    }
+    finally {
+      this.write(SYMBOLS.ShowCursor);
 
-        this.#onProcessExit();
-        process.off("exit", this.#boundExitEvent);
+      this.#onProcessExit();
+      process.off("exit", this.#boundExitEvent);
 
-        this.destroy();
-      }
-    });
+      this.destroy();
+    }
   }
 }