@reliverse/relinka 1.2.3 → 1.2.5

package/LICENSE

@@ -1,6 +1,6 @@
-MIT License
+# MIT License
 
-Copyright (c) 2024 Reliverse
+Copyright (c) 2024 Nazarii Korniienko
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -22,18 +22,12 @@
   --->
 </p>
 
-@reliverse/relinka is a powerful logger for your terminal.
-
-@reliverse/relinka is a full-featured alternative to winston, unjs relinka, pino, bristol, node-bunyan, and similar libraries.
-
-Used by [@reliverse/prompts](https://github.com/reliverse/prompts#readme) and [@reliverse/cli](https://github.com/blefnk/reliverse#readme).
+**Style your terminal or browser console like never before.** @reliverse/relinka is your next powerful logger. It's a full-featured alternative to winston, unjs relinka, pino, bristol, node-bunyan, and similar libraries. Used by [@reliverse/prompts](https://github.com/reliverse/prompts#readme) and [@reliverse/cli](https://github.com/blefnk/reliverse#readme).
 
 ## Installation
 
-Install with your preferred package manager:
-
 ```sh
-bun add @reliverse/relinka # Replace 'bun' with npm, pnpm, or yarn if desired (deno and full jsr support coming soon)
+bun add @reliverse/relinka # Replace 'bun' with npm, pnpm, or yarn if desired
 ```
 
 ---

package/dist-npm/components/levels/levels.d.ts

@@ -1,5 +1,26 @@
 import type { LogObject } from "../../types/mod.js";
+/**
+ * Defines the level of logs as specific numbers or special number types.
+ *
+ * @type {0 | 1 | 2 | 3 | 4 | 5 | (number & {})} LogLevel - Represents the log level.
+ * @default 0 - Represents the default log level.
+ */
 export type LogLevel = 0 | 1 | 2 | 3 | 4 | 5 | (number & {});
+/**
+ * A mapping of `LogType` to its corresponding numeric log level.
+ *
+ * @type {Record<LogType, number>} LogLevels - key-value pairs of log types to their numeric levels. See {@link LogType}.
+ */
 export declare const LogLevels: Record<LogType, number>;
+/**
+ * Lists the types of log messages supported by the system.
+ *
+ * @type {"silent" | "fatal" | "error" | "warn" | "log" | "info" | "success" | "fail" | "ready" | "start" | "box" | "debug" | "trace" | "verbose"} LogType - Represents the specific type of log message.
+ */
 export type LogType = "silent" | "fatal" | "error" | "warn" | "log" | "info" | "success" | "fail" | "ready" | "start" | "box" | "debug" | "trace" | "verbose";
+/**
+ * Maps `LogType` to a `Partial<LogObject>`, primarily defining the log level.
+ *
+ * @type {Record<LogType, Partial<LogObject>>} LogTypes - key-value pairs of log types to partial log objects, specifying log levels. See {@link LogType} and {@link LogObject}.
+ */
 export declare const LogTypes: Record<LogType, Partial<LogObject>>;

package/dist-npm/components/levels/levels.js

@@ -15,26 +15,26 @@ export const LogLevels = {
   verbose: Number.POSITIVE_INFINITY
 };
 export const LogTypes = {
-  
+  // Silent
   silent: {
     level: -1
   },
-  
+  // Level 0
   fatal: {
     level: LogLevels.fatal
   },
   error: {
     level: LogLevels.error
   },
-  
+  // Level 1
   warn: {
     level: LogLevels.warn
   },
-  
+  // Level 2
   log: {
     level: LogLevels.log
   },
-  
+  // Level 3
   info: {
     level: LogLevels.info
   },
@@ -53,15 +53,15 @@ export const LogTypes = {
   box: {
     level: LogLevels.info
   },
-  
+  // Level 4
   debug: {
     level: LogLevels.debug
   },
-  
+  // Level 5
   trace: {
     level: LogLevels.trace
   },
-  
+  // Verbose
   verbose: {
     level: LogLevels.verbose
   }

package/dist-npm/components/messages/mapping.d.ts

@@ -0,0 +1,3 @@
+import type { ColorName, TypographyName } from "./types.js";
+export declare const colorMap: Record<ColorName, (text: string) => string>;
+export declare const typographyMap: Record<TypographyName, (text: string) => string>;

package/dist-npm/components/messages/mapping.js

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

package/dist-npm/components/messages/messages.d.ts

@@ -0,0 +1,89 @@
+import type { TypographyName } from "./types.js";
+import type { ColorName, MsgType } from "./types.js";
+import { type VariantName } from "./variants.js";
+/**
+ * Known symbol names that will have IntelliSense support
+ */
+export type SymbolName = "pointer" | "start" | "middle" | "end" | "line" | "corner_top_right" | "step_active" | "step_error" | "info";
+export type FmtMsgOptions = {
+    type: MsgType;
+    title?: string;
+    titleAfterAnim?: string;
+    content?: string | undefined;
+    titleColor?: ColorName;
+    titleTypography?: TypographyName;
+    titleVariant?: VariantName;
+    contentColor?: ColorName;
+    contentTypography?: TypographyName;
+    contentVariant?: VariantName;
+    hint?: string;
+    hintPlaceholderColor?: ColorName;
+    hintTypography?: TypographyName;
+    border?: boolean;
+    borderColor?: ColorName;
+    dontRemoveBar?: boolean;
+    variantOptions?: {
+        box?: {
+            limit?: number;
+        };
+    };
+    errorMessage?: string;
+    addNewLineBefore?: boolean;
+    addNewLineAfter?: boolean;
+    placeholder?: string;
+    horizontalLine?: boolean;
+    horizontalLineLength?: number;
+    terminalWidth?: number;
+    instructions?: string;
+    wrapTitle?: boolean;
+    wrapContent?: boolean;
+    symbol?: SymbolName;
+    customSymbol?: string;
+    symbolColor?: ColorName;
+};
+export declare const symbols: {
+    readonly pointer: string;
+    readonly start: string;
+    readonly middle: string;
+    readonly end: string;
+    readonly line: string;
+    readonly corner_top_right: string;
+    readonly step_active: string;
+    readonly step_error: string;
+    readonly info: string;
+    readonly success: string;
+};
+/**
+ * Returns a colored vertical bar symbol.
+ */
+export declare const bar: ({ borderColor, }: {
+    borderColor?: ColorName;
+}) => string;
+/**
+ * Formats a message line according to the given FmtMsgOptions.
+ * Returns both the formatted text and the number of lines it would occupy.
+ */
+export declare function fmt(opts: FmtMsgOptions): {
+    text: string;
+    lineCount: number;
+};
+/**
+ * Logs a formatted message to the console and records how many lines it occupies.
+ */
+export declare function msg(opts: FmtMsgOptions): void;
+/**
+ * Undo the last printed message by deleting its lines from the terminal.
+ * @param count How many messages to undo. Defaults to 1.
+ */
+export declare function msgUndo(count?: number): void;
+/**
+ * Undo all printed messages so far.
+ */
+export declare function msgUndoAll(): void;
+/**
+ * Prints:  "│  <text>"  (two spaces after the bar).
+ * If text is empty, it just prints "│".
+ * If indent is 1, it prints "│ <text>" (one space).
+ * If indent is 2, it prints "│  <text>" (two spaces), etc.
+ */
+export declare function printLineBar(text: string, indent?: number): void;

package/dist-npm/components/messages/messages.js

@@ -0,0 +1,329 @@
+import pc from "picocolors";
+import wrapAnsi from "wrap-ansi";
+import { colorMap, typographyMap } from "./mapping.js";
+import { isUnicodeSupported } from "./platforms.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 wrapAndStyleText(input, typographyName, colorName, variantName, borderColor) {
+  const adjustedWidth = getTerminalWidth();
+  const wrappedText = wrapAnsi(input, adjustedWidth, {
+    hard: false,
+    trim: true
+  });
+  return wrappedText.split("\n").map((line) => {
+    const isOption = line.startsWith("  ") || line.startsWith("[ ]") || line.startsWith("[x]");
+    return applyStyles(
+      line,
+      colorName && !isOption ? colorName : void 0,
+      typographyName && !isOption ? typographyName : void 0,
+      variantName && variantName !== "none" ? variantName : void 0,
+      borderColor
+    );
+  }).join("\n");
+}
+function applyStyles(text, colorName, typographyName, variantName, borderColor) {
+  let styledText = text;
+  if (!isValidVariant(variantName)) {
+    if (colorName && colorMap[colorName]) {
+      styledText = colorMap[colorName](styledText);
+    }
+    if (typographyName && typographyMap[typographyName]) {
+      styledText = typographyMap[typographyName](styledText);
+    }
+  } else if (variantName) {
+    styledText = variantMap[variantName](
+      [styledText],
+      void 0,
+      borderColor
+    ).toString();
+  }
+  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;
+}
+export function fmt(opts) {
+  if (!opts.borderColor) {
+    opts.borderColor = "dim";
+  }
+  const border = applyStyles(symbols.middle, opts.borderColor);
+  const borderError = applyStyles(symbols.middle, "red");
+  const borderWithSpace = `${border}  `;
+  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 MSG_CONFIGS = {
+    M_NULL: {
+      symbol: "",
+      prefix: borderWithSpace,
+      suffix: "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    },
+    M_BAR: {
+      symbol: "",
+      prefix: "",
+      suffix: "",
+      newLineBefore: false,
+      newLineAfter: false
+    },
+    M_INFO_NULL: {
+      symbol: "",
+      prefix: borderWithSpace,
+      suffix: "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    },
+    M_START: {
+      symbol: "",
+      prefix: "",
+      suffix: `
+${borderWithSpace}`,
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    },
+    M_MIDDLE: {
+      symbol: "",
+      prefix: borderWithSpace,
+      suffix: "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    },
+    M_GENERAL: {
+      symbol: opts.customSymbol ? opts.symbolColor ? colorMap[opts.symbolColor](opts.customSymbol) : opts.customSymbol : opts.symbol ? opts.symbolColor ? colorMap[opts.symbolColor](symbols[opts.symbol]) : symbols[opts.symbol] : pc.green(symbols.step_active),
+      prefix: borderWithSpace,
+      suffix: "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    },
+    M_GENERAL_NULL: {
+      symbol: "",
+      prefix: borderWithSpace,
+      suffix: opts.placeholder ? colorMap[opts.hintPlaceholderColor ?? "blue"](opts.placeholder) : "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    },
+    M_INFO: {
+      symbol: opts.customSymbol ? opts.symbolColor ? colorMap[opts.symbolColor](opts.customSymbol) : opts.customSymbol : opts.symbol ? opts.symbolColor ? colorMap[opts.symbolColor](symbols[opts.symbol]) : symbols[opts.symbol] : pc.green(symbols.info),
+      prefix: borderWithSpace,
+      suffix: "",
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? true
+    },
+    M_ERROR: {
+      symbol: opts.customSymbol ? opts.symbolColor ? colorMap[opts.symbolColor](opts.customSymbol) : opts.customSymbol : opts.symbol ? opts.symbolColor ? colorMap[opts.symbolColor](symbols[opts.symbol]) : symbols[opts.symbol] : pc.redBright(symbols.step_error),
+      prefix: borderWithSpace,
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    },
+    M_ERROR_NULL: {
+      symbol: "",
+      prefix: borderWithSpace,
+      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: borderWithSpace,
+      newLineBefore: opts.addNewLineBefore ?? false,
+      newLineAfter: opts.addNewLineAfter ?? false
+    }
+  };
+  const config = MSG_CONFIGS[opts.type];
+  if (!config) {
+    throw new Error(`Invalid message type: ${opts.type}`);
+  }
+  const {
+    symbol = "",
+    suffix = "",
+    newLineBefore = false,
+    newLineAfter = false
+  } = config;
+  function validateColorName(colorName) {
+    if (!colorMap[colorName]) {
+      throw new Error(`Invalid color name: ${colorName}`);
+    }
+  }
+  let formattedTitle = "";
+  if (opts.title) {
+    const rawTitle = opts.title;
+    if (opts.wrapTitle ?? true) {
+      formattedTitle = wrapAndStyleText(
+        rawTitle,
+        opts.titleTypography ?? "bold",
+        opts.titleColor ?? "cyan",
+        opts.titleVariant,
+        opts.borderColor
+      );
+    } else {
+      formattedTitle = applyStyles(
+        rawTitle,
+        opts.titleColor ?? "cyan",
+        opts.titleTypography ?? "bold",
+        opts.titleVariant,
+        opts.borderColor
+      );
+    }
+    if (opts.hint) {
+      const hintPlaceholderColor = opts.hintPlaceholderColor ?? "blue";
+      if (opts.hintPlaceholderColor) {
+        validateColorName(opts.hintPlaceholderColor);
+      }
+      const formattedHint = wrapAndStyleText(
+        opts.hint,
+        opts.hintTypography ?? "italic",
+        hintPlaceholderColor,
+        void 0,
+        opts.borderColor
+      );
+      formattedTitle += `
+${borderWithSpace}${formattedHint}`;
+    }
+    if (opts.placeholder && opts.type === "M_GENERAL") {
+      formattedTitle += `
+${borderWithSpace}${colorMap[opts.hintPlaceholderColor ?? "mindGradient"](opts.placeholder)}`;
+    }
+    if (opts.errorMessage) {
+      const formattedError = applyStyles(
+        opts.errorMessage,
+        "red",
+        "bold",
+        "",
+        opts.borderColor
+      );
+      formattedTitle += `
+${borderError}  ${formattedError}`;
+    }
+  }
+  let formattedContent = "";
+  if (opts.content) {
+    const rawContent = opts.content;
+    if (opts.wrapContent ?? true) {
+      formattedContent = wrapAndStyleText(
+        rawContent,
+        opts.contentTypography ?? "italic",
+        opts.contentColor ?? "dim",
+        opts.contentVariant,
+        opts.borderColor
+      );
+    } else {
+      formattedContent = applyStyles(
+        rawContent,
+        opts.contentColor ?? "dim",
+        opts.contentTypography ?? "italic",
+        opts.contentVariant,
+        opts.borderColor
+      );
+    }
+  }
+  let text = "";
+  if (opts.type === "M_BAR") {
+    text = bar({ borderColor: opts.borderColor });
+  } else {
+    text = [formattedTitle, formattedContent].filter(Boolean).join(`
+`);
+  }
+  const fullText = [
+    newLineBefore ? `
+${borderWithSpace}` : "",
+    text,
+    newLineAfter ? `
+${borderWithSpace}` : "",
+    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 borderWithSpace;
+      }
+    }
+    if (opts.type === "M_END" && opts.border && index === 0) {
+      return !opts.title ? line : `${pc.green(symbols.info)}  ${line}`;
+    }
+    if (!line.trim() || line.includes(symbols.middle)) {
+      return line;
+    }
+    if (index === 0 && symbol) {
+      return `${symbol}  ${line}`;
+    }
+    return `${borderWithSpace}${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);
+  process.stdout.write(text + `
+`);
+  printedLineStack.push(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(pc.dim("\u2502"));
+  } else {
+    console.log(`${pc.dim("\u2502")}${" ".repeat(indent)}${text}`);
+  }
+}

package/dist-npm/components/messages/mod.d.ts

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./terminal.js";
+export * from "./platforms.js";
+export * from "./mapping.js";
+export * from "./variants.js";
+export * from "./messages.js";

package/dist-npm/components/messages/mod.js

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./terminal.js";
+export * from "./platforms.js";
+export * from "./mapping.js";
+export * from "./variants.js";
+export * from "./messages.js";

package/dist-npm/components/messages/platforms.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Determines if Unicode is supported in the current terminal.
+ * @returns {boolean} True if Unicode is supported, false otherwise.
+ */
+export declare function isUnicodeSupported(): boolean;
+/**
+ * Determines the current terminal name based on environment variables.
+ * @returns {string} The name of the current terminal or "Unknown" if it cannot be determined.
+ */
+export declare function getCurrentTerminalName(): string;

package/dist-npm/components/messages/platforms.js

@@ -0,0 +1,67 @@
+import { env, isWindows, isLinux, isMacOS } from "std-env";
+export function isUnicodeSupported() {
+  if (isLinux) {
+    return env["TERM"] !== "linux";
+  }
+  return env["WT_SESSION"] !== void 0 || env["TERMINUS_SUBLIME"] !== void 0 || env["ConEmuTask"] === "{cmd::Cmder}" || env["TERM_PROGRAM"] === "Terminus-Sublime" || env["TERM_PROGRAM"] === "vscode" || env["TERM"] === "xterm-256color" || env["TERM"] === "alacritty" || env["TERMINAL_EMULATOR"] === "JetBrains-JediTerm";
+}
+export function getCurrentTerminalName() {
+  const termProgram = env["TERM_PROGRAM"];
+  const term = env["TERM"];
+  const terminalEmulator = env["TERMINAL_EMULATOR"];
+  if (termProgram) {
+    switch (termProgram.toLowerCase()) {
+      case "vscode":
+        return "VSCode Terminal";
+      case "terminus-sublime":
+        return "Terminus Sublime";
+      case "hyper":
+        return "Hyper";
+      case "iterm.app":
+      case "iterm":
+        return "iTerm2";
+      case "alacritty":
+        return "Alacritty";
+      case "wezterm":
+        return "WezTerm";
+      case "terminus":
+        return "Terminus";
+      default:
+        return `TERM_PROGRAM: ${termProgram}`;
+    }
+  }
+  if (terminalEmulator) {
+    switch (terminalEmulator.toLowerCase()) {
+      case "jetbrains-jediterm":
+        return "JetBrains JediTerm";
+      case "cmder":
+        return "Cmder";
+      case "conemu":
+        return "ConEmu";
+      default:
+        return `TERMINAL_EMULATOR: ${terminalEmulator}`;
+    }
+  }
+  if (term) {
+    switch (term.toLowerCase()) {
+      case "xterm-256color":
+        return "Xterm 256 Color";
+      case "alacritty":
+        return "Alacritty";
+      case "xterm":
+        return "Xterm";
+      case "linux":
+        return "Linux Console Kernel";
+      default:
+        return `TERM: ${term}`;
+    }
+  }
+  if (isWindows) {
+    return "Windows Terminal";
+  } else if (isMacOS) {
+    return "macOS Terminal";
+  } else if (isLinux) {
+    return "Linux Terminal";
+  }
+  return "Unknown Terminal";
+}

package/dist-npm/components/messages/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;