@reliverse/rempts-core 1.6.1

package/bin/core-impl/msg-fmt/messages.js

@@ -0,0 +1,314 @@
+import { re } from "@reliverse/relico";
+import { isUnicodeSupported } from "@reliverse/runtime";
+import wrapAnsi from "wrap-ansi";
+import { colorMap, typographyMap } from "./mapping.js";
+import {
+  deleteLastLines,
+  getExactTerminalWidth,
+  getTerminalWidth
+} from "./terminal.js";
+import { isValidVariant, variantMap } from "./variants.js";
+const unicode = isUnicodeSupported();
+const u = (c, fallback) => unicode ? c : fallback;
+export const symbols = {
+  pointer: u("\u{1F449}", ">"),
+  start: u("\u256D", "*"),
+  middle: u("\u2502", "|"),
+  end: u("\u2570", "*"),
+  line: u("\u2500", "\u2014"),
+  corner_top_right: u("\u256D", "*"),
+  step_active: u("\u25C6", "\u2666"),
+  step_error: u("\u{1F5F4}", "x"),
+  info: u("\u2139", "i"),
+  success: u("\u2705", "\u2713")
+};
+function wrapThenStyle(input, wrap, typographyName, colorName, variantName, borderColor) {
+  if (!input) return "";
+  const width = getTerminalWidth();
+  const wrappedText = wrap ? wrapAnsi(input, width, { hard: false, trim: true }) : input;
+  return wrappedText.split("\n").map(
+    (line) => applyStyles(line, colorName, typographyName, variantName, borderColor)
+  ).join("\n");
+}
+function applyStyles(text, colorName, typographyName, variantName, borderColor) {
+  let styledText = text;
+  if (variantName && isValidVariant(variantName)) {
+    styledText = variantMap[variantName](
+      [styledText],
+      void 0,
+      borderColor
+    ).toString();
+    return styledText;
+  }
+  if (colorName && colorMap[colorName]) {
+    styledText = colorMap[colorName](styledText);
+  }
+  if (typographyName && typographyMap[typographyName]) {
+    styledText = typographyMap[typographyName](styledText);
+  }
+  return styledText;
+}
+export const bar = ({
+  borderColor = "dim"
+} = {}) => {
+  if (borderColor.endsWith("Gradient")) {
+    console.error(
+      "Gradient colors are not supported for bars. Please use a solid color instead."
+    );
+    return colorMap.dim(symbols.middle);
+  }
+  return colorMap[borderColor](symbols.middle);
+};
+function countLines(text) {
+  return text.split("\n").length;
+}
+function getColoredSymbol(customSymbol, symbolName, symbolColor) {
+  if (customSymbol) {
+    return symbolColor && colorMap[symbolColor] ? colorMap[symbolColor](customSymbol) : customSymbol;
+  }
+  if (symbolName && symbols[symbolName]) {
+    return symbolColor && colorMap[symbolColor] ? colorMap[symbolColor](symbols[symbolName]) : symbols[symbolName];
+  }
+  return void 0;
+}
+function formatTitle(opts, borderTwoSpaces, borderError) {
+  let formattedTitle = "";
+  if (!opts.title) return formattedTitle;
+  const wrappedOrStyledTitle = wrapThenStyle(
+    opts.title,
+    opts.wrapTitle ?? true,
+    opts.titleTypography ?? "bold",
+    opts.titleColor ?? "cyan",
+    opts.titleVariant,
+    opts.borderColor
+  );
+  formattedTitle += wrappedOrStyledTitle;
+  if (opts.hint) {
+    const hintColor = opts.hintPlaceholderColor ?? "blue";
+    const wrappedHint = wrapThenStyle(
+      opts.hint,
+      opts.wrapTitle ?? true,
+      // same wrap logic as title by default
+      opts.hintTypography ?? "italic",
+      hintColor,
+      void 0,
+      opts.borderColor
+    );
+    formattedTitle += `
+${borderTwoSpaces}${wrappedHint}`;
+  }
+  if (opts.placeholder && opts.type === "M_GENERAL") {
+    const placeHolderColor = opts.hintPlaceholderColor ?? "blue";
+    formattedTitle += `
+${borderTwoSpaces}${colorMap[placeHolderColor](opts.placeholder)}`;
+  }
+  if (opts.errorMessage) {
+    const formattedError = applyStyles(
+      opts.errorMessage,
+      "red",
+      "bold",
+      void 0,
+      opts.borderColor
+    );
+    formattedTitle += `
+${borderError}  ${formattedError}`;
+  }
+  return formattedTitle;
+}
+function formatContent(opts) {
+  if (!opts.content) return "";
+  return wrapThenStyle(
+    opts.content,
+    opts.wrapContent ?? true,
+    opts.contentTypography ?? "italic",
+    opts.contentColor ?? "dim",
+    opts.contentVariant,
+    opts.borderColor
+  );
+}
+export function fmt(opts) {
+  if (!opts.borderColor) {
+    opts.borderColor = "dim";
+  }
+  const borderColored = applyStyles(symbols.middle, opts.borderColor);
+  const borderError = applyStyles(symbols.middle, "red");
+  const borderTwoSpaces = `${borderColored}  `;
+  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 lineLength = opts.horizontalLineLength === 0 ? getExactTerminalWidth() - 3 : opts.horizontalLineLength ?? getExactTerminalWidth() - 3;
+  const suffixStartLine = opts.borderColor ? colorMap[opts.borderColor](`${symbols.line.repeat(lineLength)}\u22B1`) : `${symbols.line.repeat(lineLength)}\u22B1`;
+  const suffixEndLine = opts.borderColor ? colorMap[opts.borderColor](`${symbols.line.repeat(lineLength)}\u22B1`) : `${symbols.line.repeat(lineLength)}\u22B1`;
+  const computedSymbol = getColoredSymbol(opts.customSymbol, opts.symbol, opts.symbolColor) ?? re.green(symbols.step_active);
+  const MESSAGE_CONFIG_MAP = {
+    M_NULL: {
+      symbol: "",
+      prefix: borderTwoSpaces,
+      suffix: "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    },
+    M_BAR: {
+      symbol: "",
+      prefix: "",
+      suffix: "",
+      newLineBefore: false,
+      newLineAfter: false
+    },
+    M_INFO_NULL: {
+      symbol: "",
+      prefix: borderTwoSpaces,
+      suffix: "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    },
+    M_START: {
+      symbol: "",
+      prefix: "",
+      suffix: `
+${borderTwoSpaces}`,
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    },
+    M_MIDDLE: {
+      symbol: "",
+      prefix: borderTwoSpaces,
+      suffix: "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    },
+    M_GENERAL: {
+      symbol: computedSymbol,
+      prefix: borderTwoSpaces,
+      suffix: "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    },
+    M_GENERAL_NULL: {
+      symbol: "",
+      prefix: borderTwoSpaces,
+      suffix: opts.placeholder ? colorMap[opts.hintPlaceholderColor ?? "blue"](opts.placeholder) : "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    },
+    M_INFO: {
+      symbol: computedSymbol || re.green(symbols.info),
+      prefix: borderTwoSpaces,
+      suffix: "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? true
+    },
+    M_ERROR: {
+      symbol: computedSymbol || re.redBright(symbols.step_error),
+      prefix: borderTwoSpaces,
+      suffix: "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    },
+    M_ERROR_NULL: {
+      symbol: "",
+      prefix: borderTwoSpaces,
+      suffix: "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    },
+    M_END: {
+      symbol: "",
+      prefix: "",
+      suffix: "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    },
+    M_NEWLINE: {
+      symbol: "",
+      prefix: borderTwoSpaces,
+      suffix: "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    }
+  };
+  const config = MESSAGE_CONFIG_MAP[opts.type];
+  if (!config) {
+    throw new Error(`Invalid message type: ${opts.type}`);
+  }
+  const { symbol, suffix, newLineBefore, newLineAfter } = config;
+  const finalTitle = formatTitle(opts, borderTwoSpaces, borderError);
+  const finalContent = formatContent(opts);
+  let text = "";
+  if (opts.type === "M_BAR") {
+    text = bar({ borderColor: opts.borderColor });
+  } else {
+    text = [finalTitle, finalContent].filter(Boolean).join("\n");
+  }
+  const fullText = [
+    newLineBefore ? `
+${borderTwoSpaces}` : "",
+    text,
+    newLineAfter ? `
+${borderTwoSpaces}` : "",
+    suffix
+  ].filter(Boolean).join("");
+  const lines = fullText.split("\n").map((line, index) => {
+    if (opts.type === "M_START") {
+      if (index === 0) {
+        return `${prefixStartLine} ${line} ${suffixStartLine}`;
+      }
+      if (index === 1) {
+        return borderTwoSpaces;
+      }
+    }
+    if (opts.type === "M_END" && opts.border && index === 0) {
+      if (!opts.title) return "";
+      return `${bar({ borderColor: opts.borderColor ?? "dim" })}  ${line}`;
+    }
+    if (!line.trim() || line.includes(symbols.middle)) {
+      return line;
+    }
+    if (index === 0 && symbol) {
+      return `${symbol}  ${line}`;
+    }
+    return `${config.prefix}${line}`;
+  });
+  if (opts.type === "M_END" && opts.border) {
+    lines.push(`${prefixEndLine}${suffixEndLine}
+`);
+  }
+  const finalText = lines.join("\n");
+  const lineCount = countLines(finalText);
+  return { text: finalText, lineCount };
+}
+const printedLineStack = [];
+export function msg(opts) {
+  const { text, lineCount } = fmt(opts);
+  if (opts.type === "M_BAR" && opts.noNewLine) {
+    process.stdout.write(text);
+  } else {
+    process.stdout.write(`${text}
+`);
+  }
+  printedLineStack.push(
+    opts.type === "M_BAR" && opts.noNewLine ? lineCount : lineCount + 1
+  );
+}
+export function msgUndo(count = 1) {
+  for (let i = 0; i < count; i++) {
+    const linesToDelete = printedLineStack.pop();
+    if (typeof linesToDelete === "number" && linesToDelete > 0) {
+      deleteLastLines(linesToDelete);
+    }
+  }
+}
+export function msgUndoAll() {
+  while (printedLineStack.length > 0) {
+    const linesToDelete = printedLineStack.pop();
+    if (typeof linesToDelete === "number" && linesToDelete > 0) {
+      deleteLastLines(linesToDelete);
+    }
+  }
+}
+export function printLineBar(text, indent = 2) {
+  if (text === "") {
+    console.log(re.dim("\u2502"));
+  } else {
+    console.log(`${re.dim("\u2502")}${" ".repeat(indent)}${text}`);
+  }
+}

package/bin/core-impl/msg-fmt/terminal.d.ts

@@ -0,0 +1,15 @@
+export declare function getTerminalHeight(): number;
+export declare function getExactTerminalWidth(): number;
+export declare function getTerminalWidth(terminalWidth?: number): number;
+/**
+ * Force line returns at specific width. This function is ANSI code friendly and it'll
+ * ignore invisible codes during width calculation.
+ * @param {string} content
+ * @return {string}
+ */
+export declare function breakLines(content: string, terminalWidth?: number): string;
+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/bin/core-impl/msg-fmt/terminal.js

@@ -0,0 +1,59 @@
+import ansiEscapes from "ansi-escapes";
+import { cursor } from "sisteransi";
+import terminalSize from "terminal-size";
+import wrapAnsi from "wrap-ansi";
+export function getTerminalHeight() {
+  return terminalSize().rows ?? 24;
+}
+export function getExactTerminalWidth() {
+  return terminalSize().columns ?? 80;
+}
+export function getTerminalWidth(terminalWidth = 0) {
+  if (terminalWidth === 0) {
+    terminalWidth = getExactTerminalWidth();
+  }
+  if (terminalWidth > 150) {
+    return terminalWidth - 40;
+  }
+  if (terminalWidth > 120) {
+    return terminalWidth - 30;
+  }
+  if (terminalWidth > 100) {
+    return terminalWidth - 20;
+  }
+  return terminalWidth;
+}
+export function breakLines(content, terminalWidth = 0) {
+  if (terminalWidth === 0) {
+    terminalWidth = getTerminalWidth();
+  }
+  return content.split("\n").flatMap(
+    (line) => wrapAnsi(line, terminalWidth, { trim: false, hard: true }).split("\n").map((str) => str.trimEnd())
+  ).join("\n");
+}
+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) {
+    console.error("Count is less than or equal to 0. Nothing to delete.");
+    return;
+  }
+  process.stdout.write(ansiEscapes.eraseLines(count));
+}
+export function countLines(text) {
+  const adjustedWidth = getTerminalWidth();
+  const lines = text.split("\n");
+  let lineCount = 0;
+  for (const line of lines) {
+    const wrapped = wrapAnsi(line, adjustedWidth, { hard: true });
+    lineCount += wrapped.split("\n").length;
+  }
+  return lineCount;
+}

package/bin/core-impl/msg-fmt/variants.d.ts

@@ -0,0 +1,11 @@
+import type { ColorName, VariantName } from "../../core-types.js";
+export declare const variantMap: {
+    doubleBox: typeof createDoubleBox;
+};
+type ValidVariant = keyof typeof variantMap;
+export declare function isValidVariant(variant: string | undefined): variant is ValidVariant;
+export declare function applyVariant(lines: string[] | string, variant?: VariantName, options?: {
+    limit?: number;
+}, borderColor?: ColorName): Promise<string>;
+declare function createDoubleBox(lines: string[], limit?: number, borderColor?: ColorName): string;
+export {};

package/bin/core-impl/msg-fmt/variants.js

@@ -0,0 +1,52 @@
+import { colorMap } from "./mapping.js";
+export const variantMap = {
+  // box: createBox,
+  doubleBox: createDoubleBox
+  // banner: createBanner,
+  // underline: createUnderline,
+};
+export function isValidVariant(variant) {
+  return variant !== void 0 && variant !== "none" && variant in variantMap;
+}
+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 = "dim";
+  }
+  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/bin/core-impl/next-steps/next-steps.d.ts

@@ -0,0 +1,14 @@
+import type { TypographyName, ColorName } from "../../core-types.js";
+import type { VariantName } from "../../core-types.js";
+type NextStepsPromptOptions = {
+    title?: string;
+    titleColor?: ColorName;
+    titleVariant?: VariantName;
+    titleTypography?: TypographyName;
+    content: string[];
+    contentColor?: ColorName;
+    contentVariant?: VariantName;
+    contentTypography?: TypographyName;
+};
+export declare function nextStepsPrompt(options: NextStepsPromptOptions): Promise<void>;
+export {};

package/bin/core-impl/next-steps/next-steps.js

@@ -0,0 +1,24 @@
+import { msg } from "../msg-fmt/messages.js";
+export async function nextStepsPrompt(options) {
+  const {
+    title = "",
+    titleColor = "cyan",
+    titleVariant,
+    titleTypography = "none",
+    content = [],
+    contentColor = "dim",
+    contentVariant,
+    contentTypography = "italic"
+  } = options;
+  msg({
+    type: "M_INFO",
+    title,
+    titleColor,
+    titleTypography,
+    ...titleVariant ? { titleVariant } : {},
+    content: Array.isArray(content) ? content.join("\n") : content,
+    contentColor,
+    contentTypography,
+    ...contentVariant ? { contentVariant } : {}
+  });
+}

package/bin/core-impl/number/number-mod.d.ts

@@ -0,0 +1,28 @@
+import type { BorderColorName, ColorName, FmtMsgOptions, TypographyName } from "../../core-types.js";
+type VariantName = FmtMsgOptions["titleVariant"];
+type NumberPromptOptions = {
+    title: string;
+    hint?: string;
+    hintPlaceholderColor?: ColorName;
+    validate?: (value: number) => string | undefined | boolean | Promise<string | undefined | boolean>;
+    defaultValue?: string | number;
+    schema?: any;
+    titleColor?: ColorName;
+    titleTypography?: TypographyName;
+    titleVariant?: VariantName;
+    content?: string;
+    contentColor?: ColorName;
+    contentTypography?: TypographyName;
+    contentVariant?: VariantName;
+    borderColor?: BorderColorName;
+    variantOptions?: any;
+    endTitle?: string;
+    endTitleColor?: ColorName;
+    border?: boolean;
+    hardcoded?: {
+        userInput?: string;
+        errorMessage?: string;
+    };
+};
+export declare function numberPrompt(opts: NumberPromptOptions): Promise<number>;
+export {};