@topcli/prompts 1.5.0 → 1.6.0

package/README.md

@@ -108,6 +108,8 @@ const os = await multiselect('Choose OS', {
 });
 ```
 
+Use `autocomplete` to allow filtered choices. This can be usefull for a large list of choices.
+
 ### `confirm()`
 
 ```ts
@@ -177,6 +179,7 @@ export interface MultiselectOptions extends SharedOptions  {
   maxVisible?: number;
   preSelectedChoices?: (Choice | string)[];
   validators?: Validator[];
+  autocomplete?: boolean;
 }
 
 export interface ConfirmOptions extends SharedOptions  {

package/index.d.ts

@@ -35,6 +35,7 @@ export interface MultiselectOptions extends SharedOptions  {
   maxVisible?: number;
   preSelectedChoices?: (Choice | string)[];
   validators?: Validator[];
+  autocomplete?: boolean;
 }
 
 export interface ConfirmOptions extends SharedOptions  {

package/index.js

@@ -1,31 +1,28 @@
 // Import Internal Dependencies
-import { ConfirmPrompt } from "./src/confirm-prompt.js";
-import { SelectPrompt } from "./src/select-prompt.js";
-import { QuestionPrompt } from "./src/question-prompt.js";
+import * as prompts from "./src/prompts/index.js";
 import { required } from "./src/validators.js";
 import { PromptAgent } from "./src/prompt-agent.js";
-import { MultiselectPrompt } from "./src/multiselect-prompt.js";
 
 export async function question(message, options = {}) {
-  const questionPrompt = new QuestionPrompt(message, options);
+  const questionPrompt = new prompts.QuestionPrompt(message, options);
 
   return questionPrompt.question();
 }
 
 export async function select(message, options) {
-  const selectPrompt = new SelectPrompt(message, options);
+  const selectPrompt = new prompts.SelectPrompt(message, options);
 
   return selectPrompt.select();
 }
 
 export async function confirm(message, options) {
-  const confirmPrompt = new ConfirmPrompt(message, options);
+  const confirmPrompt = new prompts.ConfirmPrompt(message, options);
 
   return confirmPrompt.confirm();
 }
 
 export async function multiselect(message, options) {
-  const multiselectPrompt = new MultiselectPrompt(message, options);
+  const multiselectPrompt = new prompts.MultiselectPrompt(message, options);
 
   return multiselectPrompt.multiselect();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@topcli/prompts",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Node.js user input library for command-line interfaces.",
   "scripts": {
     "test": "node --no-warnings=ExperimentalWarning --loader=esmock --test test/",
@@ -30,9 +30,8 @@
     "esmock": "^2.5.2"
   },
   "dependencies": {
-    "is-unicode-supported": "^1.3.0",
-    "kleur": "^4.1.5",
-    "strip-ansi": "^7.1.0"
+    "@topcli/wcwidth": "^1.0.1",
+    "kleur": "^4.1.5"
   },
   "engines": {
     "node": ">=14"

package/src/constants.js

@@ -1,6 +1,8 @@
 // Import Third-party Dependencies
 import kleur from "kleur";
-import isUnicodeSupported from "is-unicode-supported";
+
+// Import Internal Dependencies
+import { isUnicodeSupported } from "./utils.js";
 
 const kMainSymbols = {
   tick: "✔",
@@ -20,7 +22,7 @@ const kFallbackSymbols = {
   active: "(+)",
   inactive: "(-)"
 };
-const kSymbols = isUnicodeSupported() ? kMainSymbols : kFallbackSymbols;
+const kSymbols = isUnicodeSupported() || process.env.CI ? kMainSymbols : kFallbackSymbols;
 const kPointer = kleur.gray(kSymbols.pointer);
 
 export const SYMBOLS = {

package/src/{abstract-prompt.js → prompts/abstract.js}

@@ -3,11 +3,9 @@ import { EOL } from "node:os";
 import { createInterface } from "node:readline";
 import { Writable } from "node:stream";
 
-// Import Third-party Dependencies
-import stripAnsi from "strip-ansi";
-
 // Import Internal Dependencies
-import { PromptAgent } from "./prompt-agent.js";
+import { stripAnsi } from "../utils.js";
+import { PromptAgent } from "../prompt-agent.js";
 
 export class AbstractPrompt {
   constructor(message, input = process.stdin, output = process.stdout) {

package/src/{confirm-prompt.js → prompts/confirm.js}

@@ -3,10 +3,12 @@ import { EOL } from "node:os";
 
 // Import Third-party Dependencies
 import kleur from "kleur";
+import wcwidth from "@topcli/wcwidth";
 
 // Import Internal Dependencies
-import { AbstractPrompt } from "./abstract-prompt.js";
-import { SYMBOLS } from "./constants.js";
+import { AbstractPrompt } from "./abstract.js";
+import { stripAnsi } from "../utils.js";
+import { SYMBOLS } from "../constants.js";
 
 // CONSTANTS
 const kToggleKeys = new Set([
@@ -65,7 +67,10 @@ export class ConfirmPrompt extends AbstractPrompt {
   }
 
   #onKeypress(resolve, value, key) {
-    this.stdout.moveCursor(-this.#getQuestionQuery().length, 0);
+    this.stdout.moveCursor(
+      -this.stdout.columns,
+      -Math.floor(wcwidth(stripAnsi(this.#getQuestionQuery())) / this.stdout.columns)
+    );
     this.stdout.clearScreenDown();
 
     if (key.name === "return") {
@@ -92,7 +97,11 @@ export class ConfirmPrompt extends AbstractPrompt {
   }
 
   #onQuestionAnswer() {
-    this.clearLastLine();
+    this.stdout.moveCursor(
+      -this.stdout.columns,
+      -(Math.floor(wcwidth(stripAnsi(this.#getQuestionQuery())) / this.stdout.columns) || 1)
+    );
+    this.stdout.clearScreenDown();
     this.write(`${this.selectedValue ? SYMBOLS.Tick : SYMBOLS.Cross} ${kleur.bold(this.message)}${EOL}`);
   }
 

package/src/prompts/index.js

@@ -0,0 +1,12 @@
+// Import Internal Dependencies
+import { QuestionPrompt } from "./question.js";
+import { ConfirmPrompt } from "./confirm.js";
+import { SelectPrompt } from "./select.js";
+import { MultiselectPrompt } from "./multiselect.js";
+
+export {
+  QuestionPrompt,
+  ConfirmPrompt,
+  SelectPrompt,
+  MultiselectPrompt
+};

package/src/prompts/multiselect.js

@@ -0,0 +1,333 @@
+// Import Node.js Dependencies
+import { EOL } from "node:os";
+
+// Import Third-party Dependencies
+import kleur from "kleur";
+import wcwidth from "@topcli/wcwidth";
+
+// Import Internal Dependencies
+import { AbstractPrompt } from "./abstract.js";
+import { stripAnsi } from "../utils.js";
+import { SYMBOLS } from "../constants.js";
+
+// CONSTANTS
+const kRequiredChoiceProperties = ["label", "value"];
+
+export class MultiselectPrompt extends AbstractPrompt {
+  #boundExitEvent = () => void 0;
+  #boundKeyPressEvent = () => void 0;
+  #validators;
+
+  activeIndex = 0;
+  selectedIndexes = [];
+  questionMessage;
+  autocompleteValue = "";
+
+  get choices() {
+    return this.options.choices;
+  }
+
+  get filteredChoices() {
+    return this.options.autocomplete && this.autocompleteValue.length > 0 ? this.choices.filter((choice) => {
+      if (typeof choice === "string") {
+        if (this.autocompleteValue.includes(" ")) {
+          return this.autocompleteValue.split(" ").every((word) => choice.includes(word)) ||
+          choice.includes(this.autocompleteValue);
+        }
+
+        return choice.includes(this.autocompleteValue);
+      }
+
+      if (this.autocompleteValue.includes(" ")) {
+        return this.autocompleteValue.split(" ").every((word) => choice.label.includes(word)) ||
+        choice.label.includes(this.autocompleteValue);
+      }
+
+      return choice.label.includes(this.autocompleteValue);
+    }) : this.choices;
+  }
+
+  get longestChoice() {
+    return Math.max(...this.filteredChoices.map((choice) => {
+      if (typeof choice === "string") {
+        return choice.length;
+      }
+
+      return choice.label.length;
+    }));
+  }
+
+  constructor(message, options) {
+    const {
+      stdin = process.stdin,
+      stdout = process.stdout,
+      choices,
+      preSelectedChoices,
+      validators = []
+    } = options ?? {};
+
+    super(message, stdin, stdout);
+
+    if (!options) {
+      this.destroy();
+      throw new TypeError("Missing required options");
+    }
+
+    this.options = options;
+
+    if (!choices?.length) {
+      this.destroy();
+      throw new TypeError("Missing required param: choices");
+    }
+
+    this.#validators = validators;
+
+    for (const choice of choices) {
+      if (typeof choice === "string") {
+        continue;
+      }
+
+      for (const prop of kRequiredChoiceProperties) {
+        if (!choice[prop]) {
+          this.destroy();
+          throw new TypeError(`Missing ${prop} for choice ${JSON.stringify(choice)}`);
+        }
+      }
+    }
+
+    if (!preSelectedChoices) {
+      return;
+    }
+
+    for (const choice of preSelectedChoices) {
+      const choiceIndex = this.filteredChoices.findIndex((item) => {
+        if (typeof item === "string") {
+          return item === choice;
+        }
+
+        return item.value === choice;
+      });
+
+      if (choiceIndex === -1) {
+        throw new Error(`Invalid pre-selected choice: ${choice.value ?? choice}`);
+      }
+
+      this.selectedIndexes.push(choiceIndex);
+    }
+  }
+
+  #getFormattedChoice(choiceIndex) {
+    const choice = this.filteredChoices[choiceIndex];
+
+    if (typeof choice === "string") {
+      return { value: choice, label: choice };
+    }
+
+    return choice;
+  }
+
+  #getVisibleChoices() {
+    const maxVisible = this.options.maxVisible || 8;
+    let startIndex = Math.min(this.filteredChoices.length - maxVisible, this.activeIndex - Math.floor(maxVisible / 2));
+    if (startIndex < 0) {
+      startIndex = 0;
+    }
+
+    const endIndex = Math.min(startIndex + maxVisible, this.filteredChoices.length);
+
+    return { startIndex, endIndex };
+  }
+
+  #showChoices() {
+    const { startIndex, endIndex } = this.#getVisibleChoices();
+    this.lastRender = { startIndex, endIndex };
+
+    if (this.options.autocomplete) {
+      this.write(`${SYMBOLS.Pointer} ${this.autocompleteValue}${EOL}`);
+    }
+    for (let choiceIndex = startIndex; choiceIndex < endIndex; choiceIndex++) {
+      const choice = this.#getFormattedChoice(choiceIndex);
+      const isChoiceActive = choiceIndex === this.activeIndex;
+      const isChoiceSelected = this.selectedIndexes.includes(choiceIndex);
+      const showPreviousChoicesArrow = startIndex > 0 && choiceIndex === startIndex;
+      const showNextChoicesArrow = endIndex < this.filteredChoices.length && choiceIndex === endIndex - 1;
+
+      let prefixArrow = "  ";
+      if (showPreviousChoicesArrow) {
+        prefixArrow = SYMBOLS.Previous + " ";
+      }
+      else if (showNextChoicesArrow) {
+        prefixArrow = SYMBOLS.Next + " ";
+      }
+
+      const prefix = `${prefixArrow}${isChoiceSelected ? SYMBOLS.Active : SYMBOLS.Inactive}`;
+      const formattedLabel = choice.label.padEnd(
+        this.longestChoice < 10 ? this.longestChoice : 0
+      );
+      const formattedDescription = choice.description ? ` - ${choice.description}` : "";
+      const color = isChoiceActive ? kleur.white().bold : kleur.gray;
+      const str = `${prefix} ${color(`${formattedLabel}${formattedDescription}`)}${EOL}`;
+
+      this.write(str);
+    }
+  }
+
+  #showAnsweredQuestion(choices, isAgentAnswer = false) {
+    const prefixSymbol = this.selectedIndexes.length === 0 && !isAgentAnswer ? SYMBOLS.Cross : SYMBOLS.Tick;
+    const prefix = `${prefixSymbol} ${kleur.bold(this.message)} ${SYMBOLS.Pointer}`;
+    const formattedChoice = kleur.yellow(choices);
+
+    this.write(`${prefix}${choices ? ` ${formattedChoice}` : ""}${EOL}`);
+  }
+
+  #onProcessExit() {
+    this.stdin.off("keypress", this.#boundKeyPressEvent);
+    this.stdout.moveCursor(-this.stdout.columns, 0);
+    this.stdout.clearScreenDown();
+    this.write(SYMBOLS.ShowCursor);
+  }
+
+  #onKeypress(...args) {
+    const [resolve, render, _, key] = args;
+    if (key.name === "up") {
+      this.activeIndex = this.activeIndex === 0 ? this.filteredChoices.length - 1 : this.activeIndex - 1;
+      render();
+    }
+    else if (key.name === "down") {
+      this.activeIndex = this.activeIndex === this.filteredChoices.length - 1 ? 0 : this.activeIndex + 1;
+      render();
+    }
+    else if (key.ctrl && key.name === "a") {
+      // eslint-disable-next-line max-len
+      this.selectedIndexes = this.selectedIndexes.length === this.filteredChoices.length ? [] : this.filteredChoices.map((_, index) => index);
+      render();
+    }
+    else if (key.name === "right") {
+      this.selectedIndexes.push(this.activeIndex);
+      render();
+    }
+    else if (key.name === "left") {
+      this.selectedIndexes = this.selectedIndexes.filter((index) => index !== this.activeIndex);
+      render();
+    }
+    else if (key.name === "return") {
+      const labels = this.selectedIndexes.map((index) => this.filteredChoices[index].label ?? this.filteredChoices[index]);
+      const values = this.selectedIndexes.map((index) => this.filteredChoices[index].value ?? this.filteredChoices[index]);
+
+      for (const validator of this.#validators) {
+        if (!validator.validate(values)) {
+          const error = validator.error(values);
+          render({ error });
+
+          return;
+        }
+      }
+
+      render({ clearRender: true });
+
+      this.#showAnsweredQuestion(labels.join(", "));
+
+      this.write(SYMBOLS.ShowCursor);
+      this.destroy();
+
+      this.#onProcessExit();
+      process.off("exit", this.#boundExitEvent);
+
+      resolve(values);
+    }
+    else {
+      if (!key.ctrl && this.options.autocomplete) {
+        // reset selected choices when user type
+        this.selectedIndexes = [];
+        this.activeIndex = 0;
+        if (key.name === "backspace" && this.autocompleteValue.length > 0) {
+          this.autocompleteValue = this.autocompleteValue.slice(0, -1);
+        }
+        else if (key.name !== "backspace") {
+          this.autocompleteValue += key.sequence;
+        }
+      }
+      render();
+    }
+  }
+
+  async multiselect() {
+    if (this.agent.nextAnswers.length > 0) {
+      const answer = this.agent.nextAnswers.shift();
+      this.#showAnsweredQuestion(answer, true);
+      this.destroy();
+
+      return answer;
+    }
+
+    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 linesToClear = Math.ceil(
+            wcwidth(`${SYMBOLS.Pointer} ${this.autocompleteValue}`) / this.stdout.columns
+          );
+          while (linesToClear > 0) {
+            this.clearLastLine();
+            linesToClear--;
+          }
+        }
+      }
+
+      if (clearRender) {
+        const questionLineCount = Math.ceil(
+          wcwidth(stripAnsi(this.questionMessage)) / this.stdout.columns
+        );
+        this.stdout.moveCursor(-this.stdout.columns, -(1 + questionLineCount));
+        this.stdout.clearScreenDown();
+
+        return;
+      }
+
+      if (error) {
+        const linesToClear = Math.ceil(wcwidth(this.questionMessage) / this.stdout.columns) + 1;
+        this.stdout.moveCursor(0, -linesToClear);
+        this.stdout.clearScreenDown();
+        this.#showQuestion(error);
+      }
+
+      this.#showChoices();
+    };
+
+    render({ initialRender: true });
+
+    return new Promise((resolve) => {
+      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);
+    });
+  }
+
+  #showQuestion(error = null) {
+    let hint = kleur.gray(
+      // eslint-disable-next-line max-len
+      `(Press ${kleur.bold("<Ctrl+A>")} to toggle all, ${kleur.bold("<Ctrl+Space>")} to select, ${kleur.bold("<Left/Right>")} to toggle, ${kleur.bold("<Return>")} to submit)`
+    );
+    if (error) {
+      hint += ` ${kleur.red().bold(`[${error}]`)}`;
+    }
+    this.questionMessage = `${SYMBOLS.QuestionMark} ${kleur.bold(this.message)} ${hint}`;
+
+    this.write(`${this.questionMessage}${EOL}`);
+  }
+}

package/src/{question-prompt.js → prompts/question.js}

@@ -3,10 +3,12 @@ import { EOL } from "node:os";
 
 // Import Third-party Dependencies
 import kleur from "kleur";
+import wcwidth from "@topcli/wcwidth";
 
 // Import Internal Dependencies
-import { AbstractPrompt } from "./abstract-prompt.js";
-import { SYMBOLS } from "./constants.js";
+import { AbstractPrompt } from "./abstract.js";
+import { stripAnsi } from "../utils.js";
+import { SYMBOLS } from "../constants.js";
 
 export class QuestionPrompt extends AbstractPrompt {
   #validators;
@@ -64,7 +66,12 @@ export class QuestionPrompt extends AbstractPrompt {
   }
 
   #onQuestionAnswer() {
-    this.clearLastLine();
+    const questionLineCount = Math.ceil(
+      wcwidth(stripAnsi(this.#getQuestionQuery() + this.answer)) / this.stdout.columns
+    );
+
+    this.stdout.moveCursor(-this.stdout.columns, -questionLineCount);
+    this.stdout.clearScreenDown();
 
     for (const validator of this.#validators) {
       if (!validator.validate(this.answer)) {

package/src/{select-prompt.js → prompts/select.js}

@@ -3,12 +3,16 @@ import { EOL } from "node:os";
 
 // Import Third-party Dependencies
 import kleur from "kleur";
+import wcwidth from "@topcli/wcwidth";
 
 // Import Internal Dependencies
-import { AbstractPrompt } from "./abstract-prompt.js";
-import { SYMBOLS } from "./constants.js";
+import { AbstractPrompt } from "./abstract.js";
+import { stripAnsi } from "../utils.js";
+import { SYMBOLS } from "../constants.js";
 
 export class SelectPrompt extends AbstractPrompt {
+  #boundExitEvent = () => void 0;
+  #boundKeyPressEvent = () => void 0;
   activeIndex = 0;
 
   get choices() {
@@ -113,6 +117,46 @@ export class SelectPrompt extends AbstractPrompt {
     this.write(`${prefix} ${formattedChoice}${EOL}`);
   }
 
+  #onProcessExit() {
+    this.stdin.off("keypress", this.#boundKeyPressEvent);
+    this.stdout.moveCursor(-this.stdout.columns, 0);
+    this.stdout.clearScreenDown();
+    this.write(SYMBOLS.ShowCursor);
+  }
+
+  #onKeypress(...args) {
+    const [resolve, render, _, key] = args;
+
+    if (key.name === "up") {
+      this.activeIndex = this.activeIndex === 0 ? this.choices.length - 1 : this.activeIndex - 1;
+      render();
+    }
+    else if (key.name === "down") {
+      this.activeIndex = this.activeIndex === this.choices.length - 1 ? 0 : this.activeIndex + 1;
+      render();
+    }
+    else if (key.name === "return") {
+      render({ clearRender: true });
+
+      const currentChoice = this.choices[this.activeIndex];
+      const value = currentChoice.value ?? currentChoice;
+
+      if (!this.options.ignoreValues?.includes(value)) {
+        this.#showAnsweredQuestion(currentChoice);
+      }
+
+      this.write(SYMBOLS.ShowCursor);
+      this.destroy();
+
+      this.#onProcessExit();
+      process.off("exit", this.#boundExitEvent);
+      resolve(value);
+    }
+    else {
+      render();
+    }
+  }
+
   async select() {
     if (this.agent.nextAnswers.length > 0) {
       const answer = this.agent.nextAnswers.shift();
@@ -140,7 +184,11 @@ export class SelectPrompt extends AbstractPrompt {
       }
 
       if (clearRender) {
-        this.stdout.moveCursor(0, -2);
+        const questionLineCount = Math.ceil(
+          wcwidth(stripAnsi(this.questionMessage)) / this.stdout.columns
+        );
+
+        this.stdout.moveCursor(-this.stdout.columns, -(1 + questionLineCount));
         this.stdout.clearScreenDown();
 
         return;
@@ -152,39 +200,16 @@ export class SelectPrompt extends AbstractPrompt {
     render({ initialRender: true });
 
     return new Promise((resolve) => {
-      const onKeypress = (value, key) => {
-        if (key.name === "up") {
-          this.activeIndex = this.activeIndex === 0 ? this.choices.length - 1 : this.activeIndex - 1;
-          render();
-        }
-        else if (key.name === "down") {
-          this.activeIndex = this.activeIndex === this.choices.length - 1 ? 0 : this.activeIndex + 1;
-          render();
-        }
-        else if (key.name === "return") {
-          this.stdin.off("keypress", onKeypress);
-
-          render({ clearRender: true });
-
-          const currentChoice = this.choices[this.activeIndex];
-          const value = currentChoice.value ?? currentChoice;
-
-          if (!this.options.ignoreValues?.includes(value)) {
-            this.#showAnsweredQuestion(currentChoice);
-          }
-
-          this.write(SYMBOLS.ShowCursor);
-          this.destroy();
-
-          resolve(value);
-        }
-      };
+      this.#boundKeyPressEvent = this.#onKeypress.bind(this, resolve, render);
+      this.stdin.on("keypress", this.#boundKeyPressEvent);
 
-      this.stdin.on("keypress", onKeypress);
+      this.#boundExitEvent = this.#onProcessExit.bind(this);
+      process.once("exit", this.#boundExitEvent);
     });
   }
 
   #showQuestion() {
-    this.write(`${SYMBOLS.QuestionMark} ${kleur.bold(this.message)}${EOL}`);
+    this.questionMessage = `${SYMBOLS.QuestionMark} ${kleur.bold(this.message)}`;
+    this.write(`${this.questionMessage}${EOL}`);
   }
 }

package/src/utils.js

@@ -0,0 +1,43 @@
+import process from "node:process";
+
+// CONSTANTS
+const kAnsiRegex = ansiRegex();
+
+/**
+ * @see https://github.com/chalk/ansi-regex
+ */
+export function ansiRegex({onlyFirst = false} = {}) {
+	const pattern = [
+		'[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+		'(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))'
+	].join('|');
+
+	return new RegExp(pattern, onlyFirst ? undefined : 'g');
+}
+
+/**
+ * @param {!string} string
+ * @returns {string}
+ */
+export function stripAnsi(string) {
+  return string.replace(kAnsiRegex, "");
+}
+
+/**
+ * @see https://github.com/sindresorhus/is-unicode-supported
+ * @returns {boolean}
+ */
+export function isUnicodeSupported() {
+	if (process.platform !== 'win32') {
+		return process.env.TERM !== 'linux'; // Linux console (kernel)
+	}
+
+	return Boolean(process.env.WT_SESSION) // Windows Terminal
+		|| Boolean(process.env.TERMINUS_SUBLIME) // Terminus (<0.2.27)
+		|| process.env.ConEmuTask === '{cmd::Cmder}' // ConEmu and cmder
+		|| process.env.TERM_PROGRAM === 'Terminus-Sublime'
+		|| process.env.TERM_PROGRAM === 'vscode'
+		|| process.env.TERM === 'xterm-256color'
+		|| process.env.TERM === 'alacritty'
+		|| process.env.TERMINAL_EMULATOR === 'JetBrains-JediTerm';
+}

package/src/multiselect-prompt.js

@@ -1,257 +0,0 @@
-// Import Node.js Dependencies
-import { EOL } from "node:os";
-
-// Import Third-party Dependencies
-import kleur from "kleur";
-
-// Import Internal Dependencies
-import { AbstractPrompt } from "./abstract-prompt.js";
-import { SYMBOLS } from "./constants.js";
-
-export class MultiselectPrompt extends AbstractPrompt {
-  #validators;
-
-  activeIndex = 0;
-  selectedIndexes = [];
-
-  get choices() {
-    return this.options.choices;
-  }
-
-  constructor(message, options) {
-    const {
-      stdin = process.stdin,
-      stdout = process.stdout,
-      choices,
-      preSelectedChoices,
-      validators = []
-    } = options ?? {};
-
-    super(message, stdin, stdout);
-
-    if (!options) {
-      this.destroy();
-      throw new TypeError("Missing required options");
-    }
-
-    this.options = options;
-
-    if (!choices?.length) {
-      this.destroy();
-      throw new TypeError("Missing required param: choices");
-    }
-
-    this.longestChoice = Math.max(...choices.map((choice) => {
-      if (typeof choice === "string") {
-        return choice.length;
-      }
-
-      const kRequiredChoiceProperties = ["label", "value"];
-
-      for (const prop of kRequiredChoiceProperties) {
-        if (!choice[prop]) {
-          this.destroy();
-          throw new TypeError(`Missing ${prop} for choice ${JSON.stringify(choice)}`);
-        }
-      }
-
-      return choice.label.length;
-    }));
-
-    this.#validators = validators;
-
-    if (!preSelectedChoices) {
-      return;
-    }
-
-    for (const choice of preSelectedChoices) {
-      const choiceIndex = this.choices.findIndex((item) => {
-        if (typeof item === "string") {
-          return item === choice;
-        }
-
-        return item.value === choice;
-      });
-
-      if (choiceIndex === -1) {
-        throw new Error(`Invalid pre-selected choice: ${choice.value ?? choice}`);
-      }
-
-      this.selectedIndexes.push(choiceIndex);
-    }
-  }
-
-  #getFormattedChoice(choiceIndex) {
-    const choice = this.choices[choiceIndex];
-
-    if (typeof choice === "string") {
-      return { value: choice, label: choice };
-    }
-
-    return choice;
-  }
-
-  #getVisibleChoices() {
-    const maxVisible = this.options.maxVisible || 8;
-    let startIndex = Math.min(this.choices.length - maxVisible, this.activeIndex - Math.floor(maxVisible / 2));
-    if (startIndex < 0) {
-      startIndex = 0;
-    }
-
-    const endIndex = Math.min(startIndex + maxVisible, this.choices.length);
-
-    return { startIndex, endIndex };
-  }
-
-  #showChoices() {
-    const { startIndex, endIndex } = this.#getVisibleChoices();
-    this.lastRender = { startIndex, endIndex };
-
-    for (let choiceIndex = startIndex; choiceIndex < endIndex; choiceIndex++) {
-      const choice = this.#getFormattedChoice(choiceIndex);
-      const isChoiceActive = choiceIndex === this.activeIndex;
-      const isChoiceSelected = this.selectedIndexes.includes(choiceIndex);
-      const showPreviousChoicesArrow = startIndex > 0 && choiceIndex === startIndex;
-      const showNextChoicesArrow = endIndex < this.choices.length && choiceIndex === endIndex - 1;
-
-      let prefixArrow = "  ";
-      if (showPreviousChoicesArrow) {
-        prefixArrow = SYMBOLS.Previous + " ";
-      }
-      else if (showNextChoicesArrow) {
-        prefixArrow = SYMBOLS.Next + " ";
-      }
-
-      const prefix = `${prefixArrow}${isChoiceSelected ? SYMBOLS.Active : SYMBOLS.Inactive}`;
-      const formattedLabel = choice.label.padEnd(
-        this.longestChoice < 10 ? this.longestChoice : 0
-      );
-      const formattedDescription = choice.description ? ` - ${choice.description}` : "";
-      const color = isChoiceActive ? kleur.white().bold : kleur.gray;
-      const str = `${prefix} ${color(`${formattedLabel}${formattedDescription}`)}${EOL}`;
-
-      this.write(str);
-    }
-  }
-
-  #showAnsweredQuestion(choices, isAgentAnswer = false) {
-    const prefixSymbol = this.selectedIndexes.length === 0 && !isAgentAnswer ? SYMBOLS.Cross : SYMBOLS.Tick;
-    const prefix = `${prefixSymbol} ${kleur.bold(this.message)} ${SYMBOLS.Pointer}`;
-    const formattedChoice = kleur.yellow(choices);
-
-    this.write(`${prefix}${choices ? ` ${formattedChoice}` : ""}${EOL}`);
-  }
-
-  async multiselect() {
-    if (this.agent.nextAnswers.length > 0) {
-      const answer = this.agent.nextAnswers.shift();
-      this.#showAnsweredQuestion(answer, true);
-      this.destroy();
-
-      return answer;
-    }
-
-    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 (clearRender) {
-        this.stdout.moveCursor(0, -2);
-        this.stdout.clearScreenDown();
-
-        return;
-      }
-
-      if (error) {
-        this.stdout.moveCursor(0, -2);
-        this.stdout.clearScreenDown();
-        this.#showQuestion(error);
-      }
-
-      this.#showChoices();
-    };
-
-    render({ initialRender: true });
-
-    return new Promise((resolve) => {
-      const onKeypress = (value, key) => {
-        if (key.name === "up") {
-          this.activeIndex = this.activeIndex === 0 ? this.choices.length - 1 : this.activeIndex - 1;
-          render();
-        }
-        else if (key.name === "down") {
-          this.activeIndex = this.activeIndex === this.choices.length - 1 ? 0 : this.activeIndex + 1;
-          render();
-        }
-        else if (key.name === "a") {
-          this.selectedIndexes = this.selectedIndexes.length === this.choices.length ? [] : this.choices.map((_, index) => index);
-          render();
-        }
-        else if (key.name === "space") {
-          const isChoiceSelected = this.selectedIndexes.includes(this.activeIndex);
-
-          if (isChoiceSelected) {
-            this.selectedIndexes = this.selectedIndexes.filter((index) => index !== this.activeIndex);
-          }
-          else {
-            this.selectedIndexes.push(this.activeIndex);
-          }
-
-          render();
-        }
-        else if (key.name === "return") {
-          const labels = this.selectedIndexes.map((index) => this.choices[index].label ?? this.choices[index]);
-          const values = this.selectedIndexes.map((index) => this.choices[index].value ?? this.choices[index]);
-
-          for (const validator of this.#validators) {
-            if (!validator.validate(values)) {
-              const error = validator.error(values);
-              render({ error });
-
-              return;
-            }
-          }
-
-          this.stdin.off("keypress", onKeypress);
-
-          render({ clearRender: true });
-
-
-          this.#showAnsweredQuestion(labels.join(", "));
-
-          this.write(SYMBOLS.ShowCursor);
-          this.destroy();
-
-          resolve(values);
-        }
-      };
-
-      this.stdin.on("keypress", onKeypress);
-    });
-  }
-
-  #showQuestion(error = null) {
-    let hint = kleur.gray(
-      `(Press ${kleur.bold("<a>")} to toggle all, ${kleur.bold("<space>")} to select, ${kleur.bold("<return>")} to submit)`
-    );
-    if (error) {
-      hint += ` ${kleur.red().bold(`[${error}]`)}`;
-    }
-
-    this.write(`${SYMBOLS.QuestionMark} ${kleur.bold(this.message)} ${hint}${EOL}`);
-  }
-}