@reliverse/rempts 1.7.57 → 1.7.59

package/README.md

@@ -52,10 +52,10 @@ All main prompts APIs are available from the package root:
 import {
   // ...prompts
   inputPrompt, selectPrompt, multiselectPrompt, numberPrompt,
-  confirmPrompt, togglePrompt, taskSpinPrompt, taskProgressPrompt,
+  confirmPrompt, togglePrompt,
   startPrompt, endPrompt, resultPrompt, nextStepsPrompt,
   // ...hooks
-  useSpinner,
+  createSpinner,
   // ...launcher
   createCli, defineCommand, defineArgs,
   // ...types
@@ -71,18 +71,16 @@ import {
 
 | Prompt                    | Description                                               |
 |---------------------------|-----------------------------------------------------------|
-| `useSpinner`              | Start/stop spinner |
+| `createSpinner`           | Start/stop spinner |
 | `inputPrompt`             | Single-line input (with mask support, e.g. for passwords) |
 | `selectPrompt`            | Single-choice radio menu                                  |
 | `multiselectPrompt`       | Multi-choice checkbox menu                                |
 | `numberPrompt`            | Type-safe number input                                    |
 | `confirmPrompt`           | Yes/No toggle                                             |
 | `togglePrompt`            | Custom on/off toggles                                     |
-| `taskProgressPrompt`      | Progress bar for async tasks                              |
 | `resultPrompt`            | Show results in a styled box                              |
 | `nextStepsPrompt`         | Show next steps in a styled list                          |
 | `startPrompt`/`endPrompt` | Makes CLI start/end flows look nice                       |
-| `taskSpinPrompt`       | Async loader with spinner (possibly will be deprecated)   |
 | `datePrompt`              | Date input with format validation                         |
 | `anykeyPrompt`            | Wait for any keypress                                     |
 
@@ -95,7 +93,7 @@ To help you migrate from the different CLI frameworks, `@reliverse/rempts` has s
 | `createCli`           | `runMain`        |
 | `onCmdInit`           | `setup`          |
 | `onCmdExit`           | `cleanup`        |
-| `useSpinner`          | `spinner`        |
+| `createSpinner`       | `spinner`        |
 | `selectPrompt`        | `select`         |
 | `multiselectPrompt`   | `multiselect`    |
 | `inputPrompt`         | `text`, `input`  |
@@ -125,7 +123,7 @@ async function main() {
     defaultValue: "my-cool-project",
   });
 
-  const spinner = useSpinner({
+  const spinner = createSpinner({
     text: "Loading...",
     indicator: "timer", // or "dots"
     frames: ["◒", "◐", "◓", "◑"], // custom frames

package/bin/libs/animate/{animate-mod.js → animate-mod.ts.txt}

@@ -1,20 +1,24 @@
-import { ChalkAnimation } from "@figliolia/chalk-animation";
+import { type Animation, type AnimationName, ChalkAnimation } from "@figliolia/chalk-animation";
 import { relinka } from "@reliverse/relinka";
-import { msg } from "../msg-fmt/messages.js";
-import { deleteLastLine, getTerminalWidth } from "../msg-fmt/terminal.js";
-export const animationMap = {
+import type { BorderColorName, ColorName, MsgType, TypographyName } from "../../types";
+import { msg } from "../msg-fmt/messages";
+import { deleteLastLine, getTerminalWidth } from "../msg-fmt/terminal";
+
+export const animationMap: Record<AnimationName, (text: string) => Animation> = {
   rainbow: ChalkAnimation.rainbow,
   pulse: ChalkAnimation.pulse,
   glitch: ChalkAnimation.glitch,
   radar: ChalkAnimation.radar,
   neon: ChalkAnimation.neon,
-  karaoke: ChalkAnimation.karaoke
+  karaoke: ChalkAnimation.karaoke,
 };
-function calculateDelay(text) {
-  const baseDelay = 1e3;
+
+function calculateDelay(text: string): number {
+  const baseDelay = 1000;
   const delayPerCharacter = 50;
   return baseDelay + text.length * delayPerCharacter;
 }
+
 export async function animateText({
   title = "",
   anim,
@@ -24,32 +28,46 @@ export async function animateText({
   titleTypography = "none",
   border = true,
   borderColor = "dim",
-  horizontalLineLength = 0
+  horizontalLineLength = 0,
+}: {
+  title: string;
+  anim: AnimationName;
+  delay?: number;
+  type?: MsgType;
+  titleColor?: ColorName;
+  titleTypography?: TypographyName;
+  borderColor?: BorderColorName;
+  border?: boolean;
+  horizontalLineLength?: number;
 }) {
   if (horizontalLineLength === 0) {
     horizontalLineLength = getTerminalWidth() - 5;
   }
+
   const finalDelay = delay ?? calculateDelay(title);
   const animation = animationMap[anim](title);
+
   try {
-    await new Promise((resolve) => {
+    await new Promise<void>((resolve) => {
       setTimeout(() => {
         animation.stop();
         deleteLastLine();
-        if (title.includes("\u2502  ")) {
-          title = title.replace("\u2502  ", "");
-        } else if (title.includes("\u2139  ")) {
-          title = title.replace("\u2139  ", "");
+
+        if (title.includes("│  ")) {
+          title = title.replace("│  ", "");
+        } else if (title.includes("ℹ  ")) {
+          title = title.replace("ℹ  ", "");
         }
+
         msg({
           type,
-          title,
+          title: title,
           titleColor,
           titleTypography,
           content: "",
           borderColor,
           border,
-          horizontalLineLength
+          horizontalLineLength,
         });
         resolve();
       }, finalDelay);

package/bin/libs/figures/figures-mod.d.ts

@@ -229,7 +229,7 @@ export declare const mainSymbols: {
     lineSlash: string;
 };
 export declare const fallbackSymbols: Record<string, string>;
-export declare const figures: Record<string, string> | {
+export declare const figures: {
     tick: string;
     info: string;
     warning: string;
@@ -458,4 +458,4 @@ export declare const figures: Record<string, string> | {
     lineCross: string;
     lineBackslash: string;
     lineSlash: string;
-};
+} | Record<string, string>;

package/bin/libs/intro/intro-mod.d.ts

@@ -1,4 +1,3 @@
-import type { Fonts } from "figlet";
 import type { PreventWrongTerminalSizeOptions, PromptOptions } from "../../types";
 type StartPromptOptions = PromptOptions & {
     clearConsole?: boolean;
@@ -14,7 +13,7 @@ type StartPromptOptions = PromptOptions & {
         windowsHomeDirRoot?: boolean;
     };
     variant?: "header" | "ascii-art";
-    asciiArtFont?: Fonts;
+    asciiArtFont?: any;
 };
 export declare function introPrompt(optionsOrTitle: StartPromptOptions | string): Promise<void>;
 export {};

package/bin/libs/intro/intro-mod.js

@@ -8,7 +8,6 @@ import {
   preventWrongTerminalSize
 } from "../utils/prevent.js";
 import { pm, reliversePrompts } from "../utils/system.js";
-import { createAsciiArt } from "../visual/visual-mod.js";
 export async function introPrompt(optionsOrTitle) {
   const options = typeof optionsOrTitle === "string" ? { title: optionsOrTitle } : optionsOrTitle;
   const {
@@ -29,8 +28,8 @@ export async function introPrompt(optionsOrTitle) {
       wrongTerminalSize: true,
       windowsHomeDirRoot: true
     },
-    variant = "header",
-    asciiArtFont
+    variant = "header"
+    // asciiArtFont,
   } = options;
   let horizontalLineLength = initialHorizontalLineLength;
   if (prevent.windowsHomeDirRoot) {
@@ -47,11 +46,6 @@ export async function introPrompt(optionsOrTitle) {
   const terminalHeight = getTerminalHeight();
   const formattedTitle = title !== "" ? title : `${packageName} v${packageVersion} | ${pm.packageManager} v${pm.version} | ${getCurrentTerminalName()}${isDev && terminalWidth > 80 ? ` | isDev | w${terminalWidth} h${terminalHeight}` : ""}`;
   if (variant === "ascii-art") {
-    await createAsciiArt({
-      message: formattedTitle,
-      ...asciiArtFont !== void 0 && { font: asciiArtFont },
-      clearConsole
-    });
     return;
   }
   if (horizontalLineLength === 0) {

package/bin/libs/outro/outro-mod.d.ts

@@ -1,8 +1,7 @@
-import type { Fonts } from "figlet";
 import type { PromptOptions } from "../../types";
 type EndPromptOptions = PromptOptions & {
     variant?: "footer" | "ascii-art";
-    asciiArtFont?: Fonts;
+    asciiArtFont?: any;
 };
 export declare function outroPrompt(optionsOrTitle: EndPromptOptions | string): Promise<void>;
 export {};

package/bin/libs/outro/outro-mod.js

@@ -1,7 +1,5 @@
-import { animateText } from "../animate/animate-mod.js";
 import { msg } from "../msg-fmt/messages.js";
 import { getExactTerminalWidth } from "../msg-fmt/terminal.js";
-import { createAsciiArt } from "../visual/visual-mod.js";
 export async function outroPrompt(optionsOrTitle) {
   const options = typeof optionsOrTitle === "string" ? { title: optionsOrTitle } : optionsOrTitle;
   const {
@@ -14,24 +12,20 @@ export async function outroPrompt(optionsOrTitle) {
     border = true,
     borderColor = "dim",
     horizontalLineLength: initialHorizontalLineLength = 0,
-    variant = "footer",
-    asciiArtFont
+    variant = "footer"
+    // asciiArtFont,
   } = options;
   let horizontalLineLength = initialHorizontalLineLength;
   if (variant === "ascii-art") {
-    await createAsciiArt({
-      message: title || " ",
-      ...asciiArtFont !== void 0 && { font: asciiArtFont }
-    });
     return;
   }
   if (horizontalLineLength === 0) {
     horizontalLineLength = getExactTerminalWidth() - 3;
   }
   if (titleAnimation) {
-    await animateText({
+    await msg({
       title: title ? title : " ",
-      anim: titleAnimation,
+      // anim: titleAnimation,
       ...titleAnimationDelay !== void 0 && { delay: titleAnimationDelay },
       type: "M_END",
       titleColor,

package/bin/libs/select/select-prompt.js

@@ -225,6 +225,8 @@ export async function selectPrompt(params) {
         void confirmSelection();
       } else if (key.name === "c" && key.ctrl) {
         void endPrompt(true);
+      } else {
+        void endPrompt(true);
       }
     }
     function moveSelectionUp() {
@@ -279,6 +281,7 @@ export async function selectPrompt(params) {
       );
     }
     async function endPrompt(isCtrlC = false) {
+      deleteLastLine();
       await completePrompt(
         "select",
         isCtrlC,

package/bin/libs/spinner/spinner-impl.d.ts

@@ -0,0 +1,70 @@
+import type { WriteStream } from "node:tty";
+import { type ColorName } from "@reliverse/relico";
+import { type Spinner } from "cli-spinners";
+export declare const info: string;
+export declare const success: string;
+export declare const warning: string;
+export declare const error: string;
+export interface OraOptions {
+    text?: string | undefined;
+    spinner?: string | Spinner;
+    color?: ColorName;
+    stream?: WriteStream;
+    discardStdin?: boolean;
+    hideCursor?: boolean;
+    interval?: number;
+    isEnabled?: boolean;
+    isSilent?: boolean;
+    prefixText?: string | (() => string) | undefined;
+    suffixText?: string | (() => string) | undefined;
+    indent?: number;
+}
+export interface StopAndPersistOptions {
+    symbol?: string;
+    text?: string | undefined;
+    prefixText?: string | (() => string) | undefined;
+    suffixText?: string | (() => string) | undefined;
+}
+export interface OraPromiseOptions<T = any> extends OraOptions {
+    successText?: string | ((result: T) => string);
+    failText?: string | ((error: any) => string);
+}
+export declare class Ora {
+    #private;
+    color: ColorName;
+    lastIndent?: number;
+    _stream?: WriteStream;
+    _isEnabled?: boolean;
+    constructor(options?: string | OraOptions);
+    get indent(): number | undefined;
+    set indent(indent: number | undefined);
+    get interval(): number;
+    get spinner(): string | Spinner | undefined;
+    set spinner(spinner: string | Spinner | undefined);
+    get text(): string | undefined;
+    set text(value: string | undefined);
+    get prefixText(): string | (() => string) | undefined;
+    set prefixText(value: string | (() => string) | undefined);
+    get suffixText(): string | (() => string) | undefined;
+    set suffixText(value: string | (() => string) | undefined);
+    get isSpinning(): boolean;
+    get isEnabled(): boolean;
+    set isEnabled(value: boolean);
+    get isSilent(): boolean;
+    set isSilent(value: boolean);
+    frame(): string;
+    clear(): this;
+    render(): this;
+    start(text?: string): this;
+    stop(): this;
+    succeed(text?: string): this;
+    fail(text?: string): this;
+    warn(text?: string): this;
+    info(text?: string): this;
+    stopAndPersist(options?: StopAndPersistOptions): this;
+}
+export default function ora(options?: string | OraOptions): Ora;
+export declare function oraPromise<T>(action: ((spinner: Ora) => Promise<T>) | Promise<T>, options?: string | (OraPromiseOptions<T> & {
+    text?: string | undefined;
+})): Promise<T>;
+export { default as spinners } from "cli-spinners";

package/bin/libs/spinner/spinner-impl.js

@@ -0,0 +1,336 @@
+import process from "node:process";
+import { re } from "@reliverse/relico";
+import cliCursor from "cli-cursor";
+import cliSpinners from "cli-spinners";
+import isInteractive from "is-interactive";
+import isUnicodeSupported from "is-unicode-supported";
+import stdinDiscarder from "stdin-discarder";
+import stringWidth from "string-width";
+import stripAnsi from "strip-ansi";
+const _isUnicodeSupported = isUnicodeSupported();
+export const info = re.blue(_isUnicodeSupported ? "\u2139" : "i");
+export const success = re.green(_isUnicodeSupported ? "\u2714" : "\u221A");
+export const warning = re.yellow(_isUnicodeSupported ? "\u26A0" : "\u203C");
+export const error = re.red(_isUnicodeSupported ? "\u2716" : "\xD7");
+export class Ora {
+  #linesToClear = 0;
+  #isDiscardingStdin = false;
+  #lineCount = 0;
+  #frameIndex = -1;
+  #lastSpinnerFrameTime = 0;
+  #options;
+  #spinner;
+  #stream;
+  #id;
+  #initialInterval;
+  #isEnabled;
+  #isSilent;
+  #indent;
+  #text;
+  #prefixText;
+  #suffixText;
+  color;
+  lastIndent;
+  _stream;
+  _isEnabled;
+  constructor(options) {
+    if (typeof options === "string") {
+      options = {
+        text: options
+      };
+    }
+    this.#options = {
+      color: "cyan",
+      stream: process.stderr,
+      discardStdin: true,
+      hideCursor: true,
+      ...options
+    };
+    this.color = this.#options.color ?? "cyan";
+    this.spinner = this.#options.spinner;
+    this.#initialInterval = this.#options.interval;
+    this.#stream = this.#options.stream ?? process.stderr;
+    this.#isEnabled = typeof this.#options.isEnabled === "boolean" ? this.#options.isEnabled : isInteractive({ stream: this.#stream });
+    this.#isSilent = typeof this.#options.isSilent === "boolean" ? this.#options.isSilent : false;
+    this.text = this.#options.text ?? "";
+    this.prefixText = this.#options.prefixText ?? "";
+    this.suffixText = this.#options.suffixText ?? "";
+    this.indent = this.#options.indent ?? 0;
+    if (process.env.NODE_ENV === "test") {
+      this._stream = this.#stream;
+      this._isEnabled = this.#isEnabled;
+      Object.defineProperty(this, "_linesToClear", {
+        get() {
+          return this.#linesToClear;
+        },
+        set(newValue) {
+          this.#linesToClear = newValue;
+        }
+      });
+      Object.defineProperty(this, "_frameIndex", {
+        get() {
+          return this.#frameIndex;
+        }
+      });
+      Object.defineProperty(this, "_lineCount", {
+        get() {
+          return this.#lineCount;
+        }
+      });
+    }
+  }
+  get indent() {
+    return this.#indent;
+  }
+  set indent(indent) {
+    const indentValue = indent ?? 0;
+    if (!(indentValue >= 0 && Number.isInteger(indentValue))) {
+      throw new Error("The `indent` option must be an integer from 0 and up");
+    }
+    this.#indent = indentValue;
+    this.#updateLineCount();
+  }
+  get interval() {
+    return this.#initialInterval ?? this.#spinner.interval ?? 100;
+  }
+  get spinner() {
+    return this.#spinner;
+  }
+  set spinner(spinner) {
+    this.#frameIndex = -1;
+    this.#initialInterval = void 0;
+    if (typeof spinner === "object") {
+      if (spinner.frames === void 0) {
+        throw new Error("The given spinner must have a `frames` property");
+      }
+      this.#spinner = spinner;
+    } else if (!isUnicodeSupported()) {
+      this.#spinner = cliSpinners.line;
+    } else if (spinner === void 0) {
+      this.#spinner = cliSpinners.dots;
+    } else if (spinner !== "default" && typeof spinner === "string" && spinner in cliSpinners) {
+      this.#spinner = cliSpinners[spinner];
+    } else {
+      throw new Error(
+        `There is no built-in spinner named '${spinner}'. See https://github.com/sindresorhus/cli-spinners/blob/main/spinners.json for a full list.`
+      );
+    }
+  }
+  get text() {
+    return this.#text;
+  }
+  set text(value) {
+    this.#text = value ?? "";
+    this.#updateLineCount();
+  }
+  get prefixText() {
+    return this.#prefixText;
+  }
+  set prefixText(value) {
+    this.#prefixText = value;
+    this.#updateLineCount();
+  }
+  get suffixText() {
+    return this.#suffixText;
+  }
+  set suffixText(value) {
+    this.#suffixText = value;
+    this.#updateLineCount();
+  }
+  get isSpinning() {
+    return this.#id !== void 0;
+  }
+  #getFullPrefixText(prefixText = this.#prefixText, postfix = " ") {
+    if (typeof prefixText === "string" && prefixText !== "") {
+      return prefixText + postfix;
+    }
+    if (typeof prefixText === "function") {
+      return prefixText() + postfix;
+    }
+    return "";
+  }
+  #getFullSuffixText(suffixText = this.#suffixText, prefix = " ") {
+    if (typeof suffixText === "string" && suffixText !== "") {
+      return prefix + suffixText;
+    }
+    if (typeof suffixText === "function") {
+      return prefix + suffixText();
+    }
+    return "";
+  }
+  #updateLineCount() {
+    const columns = this.#stream.columns ?? 80;
+    const fullPrefixText = this.#getFullPrefixText(this.#prefixText, "-");
+    const fullSuffixText = this.#getFullSuffixText(this.#suffixText, "-");
+    const fullText = " ".repeat(this.#indent) + fullPrefixText + "--" + this.#text + "--" + fullSuffixText;
+    this.#lineCount = 0;
+    for (const line of stripAnsi(fullText).split("\n")) {
+      this.#lineCount += Math.max(
+        1,
+        Math.ceil(stringWidth(line, { countAnsiEscapeCodes: true }) / columns)
+      );
+    }
+  }
+  get isEnabled() {
+    return this.#isEnabled && !this.#isSilent;
+  }
+  set isEnabled(value) {
+    if (typeof value !== "boolean") {
+      throw new TypeError("The `isEnabled` option must be a boolean");
+    }
+    this.#isEnabled = value;
+  }
+  get isSilent() {
+    return this.#isSilent;
+  }
+  set isSilent(value) {
+    if (typeof value !== "boolean") {
+      throw new TypeError("The `isSilent` option must be a boolean");
+    }
+    this.#isSilent = value;
+  }
+  frame() {
+    const now = Date.now();
+    if (this.#frameIndex === -1 || now - this.#lastSpinnerFrameTime >= this.interval) {
+      this.#frameIndex = ++this.#frameIndex % this.#spinner.frames.length;
+      this.#lastSpinnerFrameTime = now;
+    }
+    const { frames } = this.#spinner;
+    let frame = frames[this.#frameIndex];
+    if (this.color) {
+      frame = re[this.color](frame ?? "");
+    }
+    const fullPrefixText = typeof this.#prefixText === "string" && this.#prefixText !== "" ? this.#prefixText + " " : "";
+    const fullText = typeof this.text === "string" ? " " + this.text : "";
+    const fullSuffixText = typeof this.#suffixText === "string" && this.#suffixText !== "" ? " " + this.#suffixText : "";
+    return fullPrefixText + frame + fullText + fullSuffixText;
+  }
+  clear() {
+    if (!this.#isEnabled || !this.#stream.isTTY) {
+      return this;
+    }
+    this.#stream.cursorTo(0);
+    for (let index = 0; index < this.#linesToClear; index++) {
+      if (index > 0) {
+        this.#stream.moveCursor(0, -1);
+      }
+      this.#stream.clearLine(1);
+    }
+    if (this.#indent || this.lastIndent !== this.#indent) {
+      this.#stream.cursorTo(this.#indent);
+    }
+    this.lastIndent = this.#indent;
+    this.#linesToClear = 0;
+    return this;
+  }
+  render() {
+    if (this.#isSilent) {
+      return this;
+    }
+    this.clear();
+    this.#stream.write(this.frame());
+    this.#linesToClear = this.#lineCount;
+    return this;
+  }
+  start(text) {
+    if (text) {
+      this.text = text;
+    }
+    if (this.#isSilent) {
+      return this;
+    }
+    if (!this.#isEnabled) {
+      if (this.text) {
+        this.#stream.write(`- ${this.text}
+`);
+      }
+      return this;
+    }
+    if (this.isSpinning) {
+      return this;
+    }
+    if (this.#options.hideCursor) {
+      cliCursor.hide(this.#stream);
+    }
+    if (this.#options.discardStdin && process.stdin.isTTY) {
+      this.#isDiscardingStdin = true;
+      stdinDiscarder.start();
+    }
+    this.render();
+    this.#id = setInterval(this.render.bind(this), this.interval);
+    return this;
+  }
+  stop() {
+    if (!this.#isEnabled) {
+      return this;
+    }
+    clearInterval(this.#id);
+    this.#id = void 0;
+    this.#frameIndex = 0;
+    this.clear();
+    if (this.#options.hideCursor) {
+      cliCursor.show(this.#stream);
+    }
+    if (this.#options.discardStdin && process.stdin.isTTY && this.#isDiscardingStdin) {
+      stdinDiscarder.stop();
+      this.#isDiscardingStdin = false;
+    }
+    return this;
+  }
+  succeed(text) {
+    return this.stopAndPersist({ symbol: success, text });
+  }
+  fail(text) {
+    return this.stopAndPersist({ symbol: error, text });
+  }
+  warn(text) {
+    return this.stopAndPersist({ symbol: warning, text });
+  }
+  info(text) {
+    return this.stopAndPersist({ symbol: info, text });
+  }
+  stopAndPersist(options = {}) {
+    if (this.#isSilent) {
+      return this;
+    }
+    const prefixText = options.prefixText ?? this.#prefixText;
+    const fullPrefixText = this.#getFullPrefixText(prefixText, " ");
+    const symbolText = options.symbol ?? " ";
+    const text = options.text ?? this.text;
+    const separatorText = symbolText ? " " : "";
+    const fullText = typeof text === "string" ? separatorText + text : "";
+    const suffixText = options.suffixText ?? this.#suffixText;
+    const fullSuffixText = this.#getFullSuffixText(suffixText, " ");
+    const textToWrite = fullPrefixText + symbolText + fullText + fullSuffixText + "\n";
+    this.stop();
+    this.#stream.write(textToWrite);
+    return this;
+  }
+}
+export default function ora(options) {
+  return new Ora(options);
+}
+export async function oraPromise(action, options) {
+  const actionIsFunction = typeof action === "function";
+  const actionIsPromise = !actionIsFunction && typeof action.then === "function";
+  if (!actionIsFunction && !actionIsPromise) {
+    throw new TypeError("Parameter `action` must be a Function or a Promise");
+  }
+  const { successText, failText } = typeof options === "object" ? options : { successText: void 0, failText: void 0 };
+  const spinnerOptions = typeof options === "object" && "text" in options ? options : typeof options === "string" ? { text: options } : {};
+  const spinner = ora(spinnerOptions).start();
+  try {
+    const promise = actionIsFunction ? action(spinner) : action;
+    const result = await promise;
+    spinner.succeed(
+      successText === void 0 ? void 0 : typeof successText === "string" ? successText : successText(result)
+    );
+    return result;
+  } catch (error2) {
+    spinner.fail(
+      failText === void 0 ? void 0 : typeof failText === "string" ? failText : failText(error2)
+    );
+    throw error2;
+  }
+}
+export { default as spinners } from "cli-spinners";