@reliverse/relinka 1.0.0

package/output/utils/prompt.js

@@ -0,0 +1,254 @@
+import { stdin, stdout } from "node:process";
+import readline from "node:readline";
+import { WriteStream } from "node:tty";
+import { cursor, erase } from "sisteransi";
+import wrap from "wrap-ansi";
+function diffLines(a, b) {
+  if (a === b) {
+    return;
+  }
+  const aLines = a.split("\n");
+  const bLines = b.split("\n");
+  const diff = [];
+  for (let i = 0; i < Math.max(aLines.length, bLines.length); i++) {
+    if (aLines[i] !== bLines[i]) {
+      diff.push(i);
+    }
+  }
+  return diff;
+}
+const cancel = Symbol("rp:cancel");
+export function isCancel(value) {
+  return value === cancel;
+}
+function setRawMode(input, value) {
+  if (input.isTTY) {
+    input.setRawMode(value);
+  }
+}
+const aliases = /* @__PURE__ */ new Map([
+  ["k", "up"],
+  ["j", "down"],
+  ["h", "left"],
+  ["l", "right"]
+]);
+const keys = /* @__PURE__ */ new Set(["up", "down", "left", "right", "space", "enter"]);
+export function createPrompt({
+  render: renderFn,
+  input = stdin,
+  output = stdout,
+  ...opts
+}, trackValue = true) {
+  const _input = input;
+  const _output = output;
+  let _rl;
+  const _opts = opts;
+  const _track = trackValue;
+  let _cursor = 0;
+  let state = "initial";
+  let value = _opts.initialValue ?? "";
+  let error = "";
+  const subscribers = /* @__PURE__ */ new Map();
+  let _prevFrame = "";
+  const self = {};
+  const _render = () => renderFn.call(self);
+  function prompt() {
+    const sink = new WriteStream(0);
+    sink._write = (chunk, encoding, done) => {
+      if (_track) {
+        value = _rl.line.replace(/\t/g, "");
+        _cursor = _rl.cursor;
+        emit("value", value);
+      }
+      done();
+    };
+    _input.pipe(sink);
+    _rl = readline.createInterface({
+      input: _input,
+      output: sink,
+      tabSize: 2,
+      prompt: "",
+      escapeCodeTimeout: 50
+    });
+    readline.emitKeypressEvents(_input, _rl);
+    _rl.prompt();
+    if (_opts.initialValue !== void 0 && _track) {
+      _rl.write(_opts.initialValue);
+    }
+    _input.on("keypress", onKeypress);
+    setRawMode(_input, true);
+    _output.on("resize", render);
+    render();
+    return new Promise((resolve) => {
+      once("submit", () => {
+        _output.write(cursor.show);
+        _output.off("resize", render);
+        setRawMode(_input, false);
+        resolve(value);
+      });
+      once("cancel", () => {
+        _output.write(cursor.show);
+        _output.off("resize", render);
+        setRawMode(_input, false);
+        resolve(cancel);
+      });
+    });
+  }
+  function on(event, cb) {
+    const arr = subscribers.get(event) ?? [];
+    arr.push({ cb });
+    subscribers.set(event, arr);
+  }
+  function once(event, cb) {
+    const arr = subscribers.get(event) ?? [];
+    arr.push({ cb, once: true });
+    subscribers.set(event, arr);
+  }
+  function emit(event, ...data) {
+    const cbs = subscribers.get(event) ?? [];
+    const cleanup = [];
+    for (const subscriber of cbs) {
+      subscriber.cb(...data);
+      if (subscriber.once) {
+        cleanup.push(() => cbs.splice(cbs.indexOf(subscriber), 1));
+      }
+    }
+    for (const cb of cleanup) {
+      cb();
+    }
+  }
+  function unsubscribe() {
+    subscribers.clear();
+  }
+  function onKeypress(char, key) {
+    if (state === "error") {
+      state = "active";
+    }
+    if (key?.name && !_track && aliases.has(key.name)) {
+      emit("cursor", aliases.get(key.name));
+    }
+    if (key?.name && keys.has(key.name)) {
+      emit("cursor", key.name);
+    }
+    if (char && (char.toLowerCase() === "y" || char.toLowerCase() === "n")) {
+      emit("confirm", char.toLowerCase() === "y");
+    }
+    if (char === "	" && _opts.placeholder) {
+      if (!value) {
+        _rl.write(_opts.placeholder);
+        emit("value", _opts.placeholder);
+      }
+    }
+    if (char) {
+      emit("key", char.toLowerCase());
+    }
+    if (key?.name === "return") {
+      if (_opts.validate) {
+        const problem = _opts.validate(value);
+        if (problem) {
+          error = problem;
+          state = "error";
+          _rl.write(value);
+        }
+      }
+      if (state !== "error") {
+        state = "submit";
+      }
+    }
+    if (char === "") {
+      state = "cancel";
+    }
+    if (state === "submit" || state === "cancel") {
+      emit("finalize");
+    }
+    render();
+    if (state === "submit" || state === "cancel") {
+      close();
+    }
+  }
+  function close() {
+    _input.unpipe();
+    _input.removeListener("keypress", onKeypress);
+    _output.write("\n");
+    setRawMode(_input, false);
+    _rl.close();
+    emit(state, value);
+    unsubscribe();
+  }
+  function restoreCursor() {
+    const lines = wrap(_prevFrame, process.stdout.columns, { hard: true }).split("\n").length - 1;
+    _output.write(cursor.move(-999, lines * -1));
+  }
+  function render() {
+    const frame = wrap(_render() || "", process.stdout.columns, {
+      hard: true
+    });
+    if (frame === _prevFrame) {
+      return;
+    }
+    if (state === "initial") {
+      _output.write(cursor.hide);
+    } else {
+      const diff = diffLines(_prevFrame, frame);
+      restoreCursor();
+      if (diff && diff.length === 1) {
+        const diffLine = diff[0];
+        _output.write(cursor.move(0, diffLine));
+        _output.write(erase.lines(1));
+        const lines = frame.split("\n");
+        _output.write(lines[diffLine]);
+        _prevFrame = frame;
+        _output.write(cursor.move(0, lines.length - diffLine - 1));
+        return;
+      } else if (diff && diff.length > 1) {
+        const diffLine = diff[0];
+        _output.write(cursor.move(0, diffLine));
+        _output.write(erase.down());
+        const lines = frame.split("\n");
+        const newLines = lines.slice(diffLine);
+        _output.write(newLines.join("\n"));
+        _prevFrame = frame;
+        return;
+      }
+      _output.write(erase.down());
+    }
+    _output.write(frame);
+    if (state === "initial") {
+      state = "active";
+    }
+    _prevFrame = frame;
+  }
+  Object.assign(self, {
+    prompt,
+    on,
+    once,
+    emit,
+    close,
+    render,
+    get state() {
+      return state;
+    },
+    set state(val) {
+      state = val;
+    },
+    get value() {
+      return value;
+    },
+    set value(val) {
+      value = val;
+    },
+    get error() {
+      return error;
+    },
+    set error(val) {
+      error = val;
+    },
+    _cursor,
+    _track,
+    _input,
+    _output,
+    _rl,
+    _opts
+  });
+  return self;
+}

package/output/utils/readline.d.ts

@@ -0,0 +1,2 @@
+export declare function resetCursorAndClear(stream: NodeJS.WritableStream, x: number, y?: number, callback?: () => void): void;
+export declare function moveCursorAndClear(stream: NodeJS.WritableStream, dx: number, dy: number, callback?: () => void): void;

package/output/utils/readline.js

@@ -0,0 +1,9 @@
+import readline from "node:readline";
+export function resetCursorAndClear(stream, x, y, callback) {
+  readline.cursorTo(stream, x, y, callback);
+  readline.clearScreenDown(stream, callback);
+}
+export function moveCursorAndClear(stream, dx, dy, callback) {
+  readline.moveCursor(stream, dx, dy, callback);
+  readline.clearScreenDown(stream, callback);
+}

package/output/utils/terminal.d.ts

@@ -0,0 +1,5 @@
+export declare function removeCursor(): void;
+export declare function restoreCursor(): void;
+export declare function deleteLastLine(): void;
+export declare function deleteLastLines(count: number): void;
+export declare function countLines(text: string): number;

package/output/utils/terminal.js

@@ -0,0 +1,33 @@
+import ansiEscapes from "ansi-escapes";
+import { cursor } from "sisteransi";
+import wrapAnsi from "wrap-ansi";
+import { msg } from "./messages.js";
+export function removeCursor() {
+  process.stdout.write(cursor.hide);
+}
+export function restoreCursor() {
+  process.stdout.write(cursor.show);
+}
+export function deleteLastLine() {
+  process.stdout.write(ansiEscapes.cursorUp(1) + ansiEscapes.eraseLine);
+}
+export function deleteLastLines(count) {
+  if (count <= 0) {
+    msg({
+      type: "M_ERROR",
+      title: "Count is less than or equal to 0. Nothing to delete."
+    });
+    return;
+  }
+  process.stdout.write(ansiEscapes.eraseLines(count));
+}
+export function countLines(text) {
+  const terminalWidth = process.stdout.columns || 80;
+  const lines = text.split("\n");
+  let lineCount = 0;
+  for (const line of lines) {
+    const wrapped = wrapAnsi(line, terminalWidth, { hard: true });
+    lineCount += wrapped.split("\n").length;
+  }
+  return lineCount;
+}

package/output/utils/variants.d.ts

@@ -0,0 +1,9 @@
+import type { ColorName, Variant } from "../types/prod";
+export declare const variantMap: {
+    doubleBox: typeof createDoubleBox;
+};
+export declare function applyVariant(lines: string[] | string, variant?: Variant, options?: {
+    limit?: number;
+}, borderColor?: ColorName): Promise<string>;
+declare function createDoubleBox(lines: string[], limit?: number, borderColor?: ColorName): string;
+export {};

package/output/utils/variants.js

@@ -0,0 +1,49 @@
+import { colorMap } from "./mapping.js";
+export const variantMap = {
+  // box: createBox,
+  doubleBox: createDoubleBox
+  // banner: createBanner,
+  // underline: createUnderline,
+};
+export async function applyVariant(lines, variant, options, borderColor) {
+  const linesArray = Array.isArray(lines) ? lines : [lines];
+  switch (variant) {
+    // case "box":
+    //   return createBox(linesArray, options?.limit);
+    case "doubleBox":
+      return createDoubleBox(linesArray, options?.limit, borderColor);
+    // case "banner":
+    //   return createBanner(linesArray);
+    // case "underline":
+    //   return createUnderline(linesArray);
+    default:
+      return linesArray.join("\n");
+  }
+}
+function createDoubleBox(lines, limit, borderColor) {
+  const processedLines = processLines(lines, limit);
+  const maxLength = Math.max(...processedLines.map((line) => line.length));
+  const indentation = "";
+  if (borderColor === void 0) {
+    borderColor = "viceGradient";
+  }
+  const topBorder = borderColor ? colorMap[borderColor](`${"\u2550".repeat(maxLength)}\u2557`) : `${"\u2550".repeat(maxLength)}\u2557`;
+  const bottomBorder = borderColor ? colorMap[borderColor](`${indentation}\u255A${"\u2550".repeat(maxLength + 2)}\u255D`) : `${indentation}\u255A${"\u2550".repeat(maxLength + 2)}\u255D`;
+  const middle = processedLines.map((line, index) => {
+    const lineIndentation = index === 0 ? indentation : indentation + "  ";
+    return `${lineIndentation}${borderColor ? colorMap[borderColor]("\u2551") : "\u2551"} ${colorMap[borderColor](line.padEnd(maxLength))} ${borderColor ? colorMap[borderColor]("\u2551") : "\u2551"}`;
+  }).join("\n");
+  return `${topBorder}
+${middle}
+${bottomBorder}`;
+}
+function processLines(lines, limit) {
+  const linesArray = Array.isArray(lines) ? lines : [lines];
+  return linesArray.map((line) => {
+    let truncatedLine = line;
+    if (limit && line.length > limit) {
+      truncatedLine = `${line.slice(0, limit - 3)}...`;
+    }
+    return truncatedLine.padEnd(limit || truncatedLine.length);
+  });
+}

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@reliverse/relinka",
+  "version": "1.0.0",
+  "description": "@reliverse/relinka is a powerful library that enables seamless, typesafe, and resilient prompts for command-line applications. Crafted with simplicity and elegance, it provides developers with an intuitive and robust way to build interactive CLIs.",
+  "scripts": {
+    "appts": "bun typecheck && bun lint && bun format",
+    "build": "unbuild && bun build.optim.ts",
+    "bunp": "bun publish",
+    "pub": "redrun build bunp",
+    "lint": "eslint --cache --fix .",
+    "format": "biome check --write .",
+    "optimize": "putout output --fix",
+    "check": "bun test",
+    "attw": "attw --pack",
+    "tsc": "tshy",
+    "knip": "knip",
+    "dev": "bun examples/run-example.ts",
+    "dev:x": "tsx examples/run-example.ts"
+  },
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reliverse/prompts.git"
+  },
+  "main": "./output/main.js",
+  "types": "./output/main.d.ts",
+  "module": "./output/main.js",
+  "exports": {
+    "import": "./output/main.js",
+    "types": "./output/main.d.ts"
+  },
+  "bugs": {
+    "url": "https://github.com/reliverse/prompts/issues",
+    "email": "blefnk@gmail.com"
+  },
+  "files": ["package.json", "README.md", "LICENSE.md", "output"],
+  "homepage": "https://github.com/reliverse/prompts",
+  "keywords": ["cli", "reliverse"],
+  "license": "MIT",
+  "dependencies": {
+    "@figliolia/chalk-animation": "^1.0.4",
+    "@sinclair/typebox": "^0.33.17",
+    "ansi-escapes": "^7.0.0",
+    "chalk": "^5.3.0",
+    "cli-spinners": "^3.2.0",
+    "cli-width": "^4.1.0",
+    "defu": "^6.1.4",
+    "detect-package-manager": "^3.0.2",
+    "figlet": "^1.8.0",
+    "fs-extra": "^11.2.0",
+    "get-pixels": "^3.3.3",
+    "gradient-string": "^3.0.0",
+    "log-update": "^6.1.0",
+    "mute-stream": "^2.0.0",
+    "node-emoji": "^2.1.3",
+    "nypm": "^0.3.12",
+    "ora": "^8.1.1",
+    "pathe": "^1.1.2",
+    "picocolors": "^1.1.1",
+    "sisteransi": "^1.0.5",
+    "wrap-ansi": "^9.0.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.16.4",
+    "@biomejs/biome": "1.9.4",
+    "@cspell/dict-npm": "^5.1.12",
+    "@eslint/js": "^9.14.0",
+    "@types/bun": "^1.1.13",
+    "@types/chalk-animation": "^1.6.3",
+    "@types/eslint__js": "^8.42.3",
+    "@types/figlet": "^1.7.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/mute-stream": "^0.0.4",
+    "@types/node": "^22.9.0",
+    "@types/sentencer": "^0.2.3",
+    "@types/tape": "^5.6.4",
+    "eslint": "^9.14.0",
+    "eslint-plugin-perfectionist": "^3.9.1",
+    "knip": "^5.36.2",
+    "mock-stdin": "^1.0.0",
+    "printj": "^1.3.1",
+    "putout": "^36.11.0",
+    "redrun": "^11.0.5",
+    "sentencer": "^0.2.1",
+    "tape": "^5.9.0",
+    "tshy": "^3.0.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3",
+    "typescript-eslint": "^8.13.0",
+    "unbuild": "^2.0.0",
+    "vitest": "^2.1.4"
+  }
+}