@reliverse/relinka 1.0.0

package/output/utils/mapping.js

@@ -0,0 +1,49 @@
+import chalk from "chalk";
+import gradient, { cristal, mind, passion, retro, vice } from "gradient-string";
+import { rainbow } from "gradient-string";
+import colors from "picocolors";
+export const colorMap = {
+  none: colors.reset,
+  inverse: colors.inverse,
+  black: colors.black,
+  blue: colors.blue,
+  blueBright: colors.blueBright,
+  cyan: colors.cyan,
+  cyanBright: colors.cyanBright,
+  bgCyan: colors.bgCyan,
+  bgCyanBright: colors.bgCyanBright,
+  dim: colors.dim,
+  gray: colors.gray,
+  green: colors.green,
+  greenBright: colors.greenBright,
+  bgGreen: colors.bgGreen,
+  bgGreenBright: colors.bgGreenBright,
+  magenta: colors.magenta,
+  red: colors.red,
+  redBright: colors.redBright,
+  bgRed: colors.bgRed,
+  bgRedBright: colors.bgRedBright,
+  white: colors.white,
+  yellow: colors.yellow,
+  yellowBright: colors.yellowBright,
+  cristalGradient: cristal,
+  mindGradient: mind,
+  passionGradient: passion,
+  rainbowGradient: rainbow,
+  retroGradient: retro,
+  viceGradient: vice,
+  gradientGradient: gradient([
+    "red",
+    "yellow",
+    "green",
+    "cyan",
+    "blue",
+    "magenta"
+  ])
+};
+export const typographyMap = {
+  bold: chalk.bold,
+  italic: chalk.italic,
+  underline: chalk.underline,
+  strikethrough: chalk.strikethrough
+};

package/output/utils/messages.d.ts

@@ -0,0 +1,17 @@
+import type { ColorName, FmtMsgOptions } from "../types/prod";
+export declare const symbols: {
+    pointer: string;
+    start: string;
+    middle: string;
+    end: string;
+    line: string;
+    corner_top_right: string;
+    step_active: string;
+    step_error: string;
+    info: string;
+};
+export declare const bar: ({ borderColor, }: {
+    borderColor?: ColorName;
+}) => string;
+export declare function fmt(opts: FmtMsgOptions): string;
+export declare function msg(opts: FmtMsgOptions): void;

package/output/utils/messages.js

@@ -0,0 +1,203 @@
+import { emojify } from "node-emoji";
+import { greenBright, redBright } from "picocolors";
+import { colorMap, typographyMap } from "../utils/mapping";
+import { isUnicodeSupported } from "../utils/platforms";
+import { variantMap } from "../utils/variants";
+const unicode = isUnicodeSupported();
+const u = (c, fallback) => unicode ? c : fallback;
+export const symbols = {
+  pointer: u("\u{1F449}", ">"),
+  start: u("\u256D", "T"),
+  middle: u("\u2502", "|"),
+  end: u("\u2570", "*"),
+  line: u("\u2500", "\u2014"),
+  corner_top_right: u("\xBB", "T"),
+  step_active: u("\u25C6", "\u2666"),
+  step_error: u("\u{1F5F4}", "x"),
+  info: u("\u2139", "i")
+};
+function applyStyles(text, colorName = "", typographyName = "", variantName = "", borderColor = "") {
+  let styledText = text;
+  if (!variantName) {
+    if (colorName && colorMap[colorName]) {
+      styledText = colorMap[colorName](styledText);
+    } else if (colorName) {
+      console.warn(
+        `Warning: Invalid color "${colorName}" provided to applyStyles.`
+      );
+    }
+    if (typographyName && typographyMap[typographyName]) {
+      styledText = typographyMap[typographyName](styledText);
+    } else if (typographyName) {
+      console.warn(
+        `Warning: Invalid typography "${typographyName}" provided to applyStyles.`
+      );
+    }
+  }
+  if (variantName && variantMap[variantName]) {
+    styledText = variantMap[variantName](styledText, borderColor);
+  } else if (variantName) {
+    console.warn(
+      `Warning: Invalid variant "${variantName}" provided to applyStyles.`
+    );
+  }
+  return styledText;
+}
+export const bar = ({
+  borderColor = "viceGradient"
+}) => colorMap[borderColor](symbols.middle);
+export function fmt(opts) {
+  if (opts.title?.includes("\u2502  ")) {
+    opts.title = opts.title.replace("\u2502  ", "");
+  }
+  if (!opts.borderColor) {
+    opts.borderColor = "viceGradient";
+  }
+  const formattedBar = bar({ borderColor: opts.borderColor });
+  const prefixStartLine = opts.borderColor ? colorMap[opts.borderColor](symbols.start + symbols.line) : symbols.start + symbols.line;
+  const prefixEndLine = opts.borderColor ? colorMap[opts.borderColor](symbols.end + symbols.line) : symbols.end + symbols.line;
+  const suffixStartLine = opts.borderColor ? colorMap[opts.borderColor](`${symbols.line.repeat(28)}\u22B1`) : `${symbols.line.repeat(28)}\u22B1`;
+  const suffixEndLine = opts.borderColor ? colorMap[opts.borderColor](`${symbols.line.repeat(58)}\u22B1`) : `${symbols.line.repeat(58)}\u22B1`;
+  const MSG_CONFIGS = {
+    M_NULL: {
+      symbol: "",
+      prefix: "",
+      suffix: "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    },
+    M_START: {
+      symbol: "",
+      prefix: prefixStartLine,
+      suffix: ` ${suffixStartLine}
+${formattedBar}`,
+      newLineBefore: false,
+      newLineAfter: false
+    },
+    M_MIDDLE: {
+      symbol: formattedBar,
+      prefix: "",
+      suffix: "",
+      newLineBefore: false,
+      newLineAfter: false
+    },
+    M_GENERAL: {
+      symbol: "",
+      prefix: greenBright(symbols.step_active),
+      suffix: "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? true
+    },
+    M_INFO: {
+      symbol: "",
+      prefix: greenBright(symbols.info),
+      suffix: "",
+      newLineBefore: false,
+      newLineAfter: true
+    },
+    M_ERROR: {
+      symbol: "",
+      // prefix: `${formattedBar}\n${s.step_error}`,
+      prefix: redBright(symbols.step_error),
+      newLineBefore: false,
+      newLineAfter: true
+    },
+    M_END: {
+      symbol: "",
+      prefix: "",
+      suffix: opts.border ? ` ${suffixEndLine}
+${formattedBar}` : "",
+      newLineBefore: false,
+      newLineAfter: true
+    },
+    M_END_ANIMATED: {
+      symbol: "",
+      prefix: greenBright(symbols.info),
+      suffix: opts.border ? `
+${formattedBar}
+${prefixEndLine}${suffixEndLine}
+` : "",
+      newLineBefore: false,
+      newLineAfter: false
+    },
+    M_NEWLINE: {
+      symbol: "",
+      prefix: formattedBar,
+      newLineBefore: false,
+      newLineAfter: false
+    }
+  };
+  const config = MSG_CONFIGS[opts.type];
+  if (!config) {
+    throw new Error(`Invalid message type: ${opts.type}`);
+  }
+  const {
+    symbol = "",
+    prefix = "",
+    suffix = "",
+    newLineBefore = false,
+    newLineAfter = false
+  } = config;
+  const formattedPrefix = prefix ? `${prefix}${opts.type === "M_START" ? " " : "  "}` : "";
+  const border = applyStyles(symbols.middle, opts.borderColor);
+  const borderError = applyStyles(symbols.middle, "red");
+  const borderWithSpace = `${border}  `;
+  let formattedTitle = "";
+  if (opts.title) {
+    formattedTitle = applyStyles(
+      opts.title,
+      opts.titleColor,
+      opts.titleTypography,
+      opts.titleVariant,
+      opts.borderColor
+    );
+    if (opts.hint) {
+      formattedTitle += `
+${borderWithSpace}${colorMap.blueBright(opts.hint)}`;
+    }
+    if (opts.errorMessage) {
+      const formattedError = applyStyles(
+        opts.errorMessage,
+        "red",
+        "bold",
+        "",
+        opts.borderColor
+      );
+      formattedTitle += `
+${borderError}  ${formattedError}`;
+    }
+  }
+  let formattedContent = "";
+  if (opts.content) {
+    const contentLines = opts.content.split("\n");
+    formattedContent = contentLines.map((line) => {
+      const styledLine = applyStyles(
+        line,
+        opts.contentColor,
+        opts.contentTypography,
+        opts.contentVariant,
+        opts.borderColor
+      );
+      if (opts.type !== "M_START") {
+        return `${borderWithSpace}${styledLine}`;
+      } else {
+        return styledLine;
+      }
+    }).join("\n");
+  }
+  const text = [formattedTitle, formattedContent].filter(Boolean).join(`
+`);
+  return [
+    symbol,
+    newLineBefore ? `
+${formattedBar}  ` : "",
+    formattedPrefix,
+    text,
+    newLineAfter ? `
+${formattedBar}  ` : "",
+    suffix
+  ].filter(Boolean).join("");
+}
+export function msg(opts) {
+  console[opts.type === "M_ERROR" ? "error" : "log"](emojify(fmt(opts)));
+}

package/output/utils/platforms.d.ts

@@ -0,0 +1 @@
+export declare function isUnicodeSupported(): boolean;

package/output/utils/platforms.js

@@ -0,0 +1,22 @@
+import process from "node:process";
+const platforms = {
+  linux: process.platform !== "win32",
+  win32: process.platform === "win32"
+};
+const terminals = {
+  linuxConsoleKernel: process.env.TERM !== "linux",
+  windowsTerminal: Boolean(process.env.WT_SESSION),
+  terminusSublimeOld: Boolean(process.env.TERMINUS_SUBLIME),
+  cmderTerminal: process.env.ConEmuTask === "{cmd::Cmder}",
+  terminusSublimeNew: process.env.TERM_PROGRAM === "Terminus-Sublime",
+  visualStudioCode: process.env.TERM_PROGRAM === "vscode",
+  xterm256color: process.env.TERM === "xterm-256color",
+  alacrittyTerminal: process.env.TERM === "alacritty",
+  jetbrainsJediTerm: process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm"
+};
+export function isUnicodeSupported() {
+  if (platforms.linux) {
+    return terminals.linuxConsoleKernel;
+  }
+  return terminals.windowsTerminal || terminals.terminusSublimeOld || terminals.cmderTerminal || terminals.terminusSublimeNew || terminals.visualStudioCode || terminals.xterm256color || terminals.alacrittyTerminal || terminals.jetbrainsJediTerm;
+}

package/output/utils/prompt-tmp.d.ts

@@ -0,0 +1,13 @@
+import type { Readable, Writable } from "node:stream";
+export declare function isCancel(value: unknown): value is symbol;
+export type PromptOptions<Self> = {
+    render(this: Omit<Self, "prompt">): string | void;
+    placeholder?: string;
+    initialValue?: any;
+    validate?: ((value: any) => string | void) | undefined;
+    input?: Readable;
+    output?: Writable;
+    debug?: boolean;
+};
+export type StateDeprecated = "initial" | "active" | "cancel" | "submit" | "error";
+export declare function createPrompt({ render: renderFn, input, output, ...opts }: PromptOptions<any>, trackValue?: boolean): any;

package/output/utils/prompt-tmp.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/prompt.d.ts

@@ -0,0 +1,13 @@
+import type { Readable, Writable } from "node:stream";
+export declare function isCancel(value: unknown): value is symbol;
+export type PromptOptions<Self> = {
+    render(this: Omit<Self, "prompt">): string | void;
+    placeholder?: string;
+    initialValue?: any;
+    validate?: ((value: any) => string | void) | undefined;
+    input?: Readable;
+    output?: Writable;
+    debug?: boolean;
+};
+export type StateDeprecated = "initial" | "active" | "cancel" | "submit" | "error";
+export declare function createPrompt({ render: renderFn, input, output, ...opts }: PromptOptions<any>, trackValue?: boolean): any;