utils.ts

import fs from "node:fs";
import { readdir } from "node:fs/promises";
import path from "node:path";
import process from "node:process";
import os from "node:os";
import { type Key as ActionKey } from "node:readline";
import { erase, cursor } from "sisteransi";
import pc from "picocolors";

// https://no-color.org/
// picocolors natively respects NO_COLOR and FORCE_COLOR env vars
const SUPPORTS_COLOR = pc.isColorSupported;

export const color = {
  supportsColor: SUPPORTS_COLOR,
  heading: safeColor(pc.bold),
  arg: safeColor(pc.yellowBright),
  error: safeColor(pc.red),
  warning: safeColor(pc.yellow),
  hint: safeColor(pc.blue),
  bold: safeColor(pc.bold),
  black: safeColor(pc.black),
  white: safeColor(pc.white),
  blue: safeColor(pc.blue),
  cyan: safeColor(pc.cyan),
  red: safeColor(pc.red),
  yellow: safeColor(pc.yellow),
  green: safeColor(pc.green),
  blackBright: safeColor(pc.blackBright),
  whiteBright: safeColor(pc.whiteBright),
  blueBright: safeColor(pc.blueBright),
  cyanBright: safeColor(pc.cyanBright),
  redBright: safeColor(pc.redBright),
  yellowBright: safeColor(pc.yellowBright),
  greenBright: safeColor(pc.greenBright),
  bgBlack: safeColor(pc.bgBlack),
  bgWhite: safeColor(pc.bgWhite),
  bgBlue: safeColor(pc.bgBlue),
  bgCyan: safeColor(pc.bgCyan),
  bgRed: safeColor(pc.bgRed),
  bgYellow: safeColor(pc.bgYellow),
  bgGreen: safeColor(pc.bgGreen),
  bgBlackBright: safeColor(pc.bgBlackBright),
  bgWhiteBright: safeColor(pc.bgWhiteBright),
  bgBlueBright: safeColor(pc.bgBlueBright),
  bgCyanBright: safeColor(pc.bgCyanBright),
  bgRedBright: safeColor(pc.bgRedBright),
  bgYellowBright: safeColor(pc.bgYellowBright),
  bgGreenBright: safeColor(pc.bgGreenBright),
  gray: safeColor(pc.gray),
  dim: safeColor(pc.dim),
  reset: safeColor(pc.reset),
  inverse: safeColor(pc.inverse),
  hex: (hex: string) => safeColor(hexColor(hex)),
  underline: pc.underline,
};

/**
 * Converts a hex color string to an ANSI true-color (24-bit) formatter.
 * Used by the loading indicator gradient animation.
 */
function hexColor(hex: string): (input: string) => string {
  let h = hex.replace("#", "");
  let r = parseInt(h.substring(0, 2), 16);
  let g = parseInt(h.substring(2, 4), 16);
  let b = parseInt(h.substring(4, 6), 16);
  return (input: string) => `\x1b[38;2;${r};${g};${b}m${input}\x1b[39m`;
}

function safeColor(style: (input: string) => string) {
  return SUPPORTS_COLOR ? style : identity;
}

export { type ActionKey };

const unicode = { enabled: os.platform() !== "win32" };
export const shouldUseAscii = () => !unicode.enabled;

export function isInteractive() {
  // Support explicit override for testing purposes
  if ("CREATE_REACT_ROUTER_FORCE_INTERACTIVE" in process.env) {
    return true;
  }

  // Adapted from https://github.com/sindresorhus/is-interactive
  return Boolean(
    process.stdout.isTTY &&
    process.env.TERM !== "dumb" &&
    !("CI" in process.env),
  );
}

export function log(message: string) {
  return process.stdout.write(message + "\n");
}

export let stderr = process.stderr;
/** @internal Used to mock `process.stderr.write` for testing purposes */
export function setStderr(writable: typeof process.stderr) {
  stderr = writable;
}

export function logError(message: string) {
  return stderr.write(message + "\n");
}

function logBullet(
  logger: typeof log | typeof logError,
  colorizePrefix: (v: string) => string,
  colorizeText: (v: string) => string,
  symbol: string,
  prefix: string,
  text?: string | string[],
) {
  let textParts = Array.isArray(text) ? text : [text || ""].filter(Boolean);
  let formattedText = textParts
    .map((textPart) => colorizeText(textPart))
    .join("");

  if (process.stdout.columns < 80) {
    logger(
      `${" ".repeat(5)} ${colorizePrefix(symbol)}  ${colorizePrefix(prefix)}`,
    );
    logger(`${" ".repeat(9)}${formattedText}`);
  } else {
    logger(
      `${" ".repeat(5)} ${colorizePrefix(symbol)}  ${colorizePrefix(
        prefix,
      )} ${formattedText}`,
    );
  }
}

export function debug(prefix: string, text?: string | string[]) {
  logBullet(log, color.yellow, color.dim, "●", prefix, text);
}

export function info(prefix: string, text?: string | string[]) {
  logBullet(log, color.cyan, color.dim, "◼", prefix, text);
}

export function success(text: string) {
  logBullet(log, color.green, color.dim, "✔", text);
}

export function error(prefix: string, text?: string | string[]) {
  log("");
  logBullet(logError, color.red, color.error, "▲", prefix, text);
}

export function sleep(ms: number) {
  return new Promise<void>((resolve) => setTimeout(resolve, ms));
}

export function toValidProjectName(projectName: string) {
  if (isValidProjectName(projectName)) {
    return projectName;
  }
  return projectName
    .trim()
    .toLowerCase()
    .replace(/\s+/g, "-")
    .replace(/^[._]/, "")
    .replace(/[^a-z\d\-~]+/g, "-")
    .replace(/^-+/, "")
    .replace(/-+$/, "");
}

function isValidProjectName(projectName: string) {
  return /^(?:@[a-z\d\-*~][a-z\d\-*._~]*\/)?[a-z\d\-~][a-z\d\-._~]*$/.test(
    projectName,
  );
}

export function identity<V>(v: V) {
  return v;
}

export function strip(str: string) {
  let pattern = [
    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))",
  ].join("|");
  let RGX = new RegExp(pattern, "g");
  return typeof str === "string" ? str.replace(RGX, "") : str;
}

export function reverse<T>(arr: T[]): T[] {
  return [...arr].reverse();
}

export function isValidJsonObject(obj: any): obj is Record<string, unknown> {
  return !!(obj && typeof obj === "object" && !Array.isArray(obj));
}

export async function directoryExists(p: string) {
  try {
    let stat = await fs.promises.stat(p);
    return stat.isDirectory();
  } catch {
    return false;
  }
}

export async function fileExists(p: string) {
  try {
    let stat = await fs.promises.stat(p);
    return stat.isFile();
  } catch {
    return false;
  }
}

export async function ensureDirectory(dir: string) {
  if (!(await directoryExists(dir))) {
    await fs.promises.mkdir(dir, { recursive: true });
  }
}

export function pathContains(path: string, dir: string) {
  let relative = path.replace(dir, "");
  return relative.length < path.length && !relative.startsWith("..");
}

export function isUrl(value: string | URL) {
  try {
    new URL(value);
    return true;
  } catch {
    return false;
  }
}

export function clear(prompt: string, perLine: number) {
  if (!perLine) return erase.line + cursor.to(0);
  let rows = 0;
  let lines = prompt.split(/\r?\n/);
  for (let line of lines) {
    rows += 1 + Math.floor(Math.max(strip(line).length - 1, 0) / perLine);
  }

  return erase.lines(rows);
}

export function lines(msg: string, perLine: number) {
  let lines = String(strip(msg) || "").split(/\r?\n/);
  if (!perLine) return lines.length;
  return lines
    .map((l) => Math.ceil(l.length / perLine))
    .reduce((a, b) => a + b);
}

export function action(key: ActionKey, isSelect: boolean) {
  if (key.meta && key.name !== "escape") return;

  if (key.ctrl) {
    if (key.name === "a") return "first";
    if (key.name === "c") return "abort";
    if (key.name === "d") return "abort";
    if (key.name === "e") return "last";
    if (key.name === "g") return "reset";
  }

  if (isSelect) {
    if (key.name === "j") return "down";
    if (key.name === "k") return "up";
  }

  if (key.name === "return") return "submit";
  if (key.name === "enter") return "submit"; // ctrl + J
  if (key.name === "backspace") return "delete";
  if (key.name === "delete") return "deleteForward";
  if (key.name === "abort") return "abort";
  if (key.name === "escape") return "exit";
  if (key.name === "tab") return "next";
  if (key.name === "pagedown") return "nextPage";
  if (key.name === "pageup") return "prevPage";
  if (key.name === "home") return "home";
  if (key.name === "end") return "end";

  if (key.name === "up") return "up";
  if (key.name === "down") return "down";
  if (key.name === "right") return "right";
  if (key.name === "left") return "left";

  return false;
}

export function stripDirectoryFromPath(dir: string, filePath: string) {
  // Can't just do a regexp replace here since the windows paths mess it up :/
  let stripped = filePath;
  if (
    (dir.endsWith(path.sep) && filePath.startsWith(dir)) ||
    (!dir.endsWith(path.sep) && filePath.startsWith(dir + path.sep))
  ) {
    stripped = filePath.slice(dir.length);
    if (stripped.startsWith(path.sep)) {
      stripped = stripped.slice(1);
    }
  }
  return stripped;
}

// We do not copy these folders from templates so we can ignore them for comparisons
export const IGNORED_TEMPLATE_DIRECTORIES = [".git", "node_modules"];

export async function getDirectoryFilesRecursive(dir: string) {
  return (await readdir(dir, { recursive: true })).filter((file) => {
    let parts = file.split(path.sep);

    return (
      parts.length <= 1 || !IGNORED_TEMPLATE_DIRECTORIES.includes(parts[0])
    );
  });
}