@reliverse/relinka 1.2.3 → 1.2.5

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

@@ -0,0 +1,57 @@
+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;
+  } else if (terminalWidth > 120) {
+    return terminalWidth - 30;
+  } else 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/dist-npm/components/messages/types.d.ts

@@ -0,0 +1,12 @@
+export type MsgType = "M_NULL" | "M_INFO_NULL" | "M_START" | "M_MIDDLE" | "M_GENERAL" | "M_GENERAL_NULL" | "M_INFO" | "M_ERROR" | "M_ERROR_NULL" | "M_END" | "M_NEWLINE" | "M_BAR";
+export type TypographyName = "bold" | "strikethrough" | "underline" | "italic" | "none";
+export type BorderColorName = "reset" | "inverse" | "dim" | "black" | "red" | "redBright" | "green" | "greenBright" | "yellow" | "yellowBright" | "blue" | "blueBright" | "magenta" | "magentaBright" | "cyan" | "cyanBright" | "bgCyan" | "bgCyanBright" | "white" | "gray";
+export type ColorName = BorderColorName | "gradientGradient" | "rainbowGradient" | "cristalGradient" | "mindGradient" | "passionGradient" | "viceGradient" | "retroGradient" | "none";
+export type MsgConfig = {
+    symbol: string;
+    prefix?: string;
+    color?: (text: string) => string;
+    newLineBefore?: boolean;
+    newLineAfter?: boolean;
+    suffix?: string;
+};

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

@@ -0,0 +1,12 @@
+import type { ColorName } from "./types.js";
+export declare const variantMap: {
+    doubleBox: typeof createDoubleBox;
+};
+type ValidVariant = keyof typeof variantMap;
+export type VariantName = ValidVariant | "none";
+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/dist-npm/components/messages/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/dist-npm/components/modes/basic.d.ts

@@ -1,8 +1,20 @@
 import type { RelinkaInstance } from "../../components/relinka/relinka.js";
 import type { RelinkaOptions } from "../../types/mod.js";
 export * from "./shared.js";
+/**
+ * Factory function to create a new Relinka instance
+ *
+ * @param {Partial<RelinkaOptions & { fancy: boolean }>} [options={}] - Optional configuration options. See {@link RelinkaOptions}.
+ * @returns {RelinkaInstance} A new Relinka instance configured with the given options.
+ */
 export declare function createRelinka(options?: Partial<RelinkaOptions & {
     fancy: boolean;
 }>): RelinkaInstance;
-export declare const relinka: RelinkaInstance;
-export default relinka;
+/**
+ * Creates and exports a standard instance of Relinka with the default configuration.
+ * This instance can be used directly for logging throughout the application.
+ *
+ * @type {RelinkaInstance} relinka - The default instance of Relinka.
+ */
+export declare const relinkaBasic: RelinkaInstance;
+export default relinkaBasic;

package/dist-npm/components/modes/basic.js

@@ -4,10 +4,10 @@ import { BasicReporter } from "../../components/reporters/basic.js";
 export * from "./shared.js";
 export function createRelinka(options = {}) {
   let level = LogLevels.info;
-  if (process.env.RELINKA_LEVEL) {
-    level = Number.parseInt(process.env.RELINKA_LEVEL) ?? level;
+  if (process.env["RELINKA_LEVEL"]) {
+    level = Number.parseInt(process.env["RELINKA_LEVEL"]) ?? level;
   }
-  const relinka2 = _createRelinka({
+  const relinka = _createRelinka({
     level,
     defaults: { level },
     stdout: process.stdout,
@@ -15,7 +15,7 @@ export function createRelinka(options = {}) {
     reporters: options.reporters || [new BasicReporter()],
     ...options
   });
-  return relinka2;
+  return relinka;
 }
-export const relinka = createRelinka();
-export default relinka;
+export const relinkaBasic = createRelinka();
+export default relinkaBasic;

package/dist-npm/components/modes/browser.d.ts

@@ -1,5 +1,19 @@
 import type { RelinkaOptions } from "../../types/mod.js";
 export * from "./shared.js";
+/**
+ * Creates a new Relinka instance configured specifically for browser environments.
+ * This function sets up default reporters and a prompt method tailored to the browser's dialogue APIs.
+ *
+ * @param {Partial<RelinkaOptions>} [options={}] - Optional configuration options.
+ * The options can override the default reporter and prompt behavior. See {@link RelinkaOptions}.
+ * @returns {RelinkaInstance} A new Relinka instance optimized for use in browser environments.
+ */
 export declare function createRelinka(options?: Partial<RelinkaOptions>): any;
-export declare const relinka: any;
-export default relinka;
+/**
+ * A standard Relinka instance created with browser-specific configurations.
+ * This instance can be used throughout a browser-based project.
+ *
+ * @type {RelinkaInstance} relinka - The default browser-configured Relinka instance.
+ */
+export declare const relinkaBrowser: any;
+export default relinkaBrowser;

package/dist-npm/components/modes/browser.js

@@ -1,12 +1,12 @@
-import { BrowserReporter } from "../../components/reporters/browser.js";
 import { createRelinka as _createRelinka } from "../../components/relinka/relinka.js";
+import { BrowserReporter } from "../../components/reporters/browser.js";
 export * from "./shared.js";
 export function createRelinka(options = {}) {
-  const relinka2 = _createRelinka({
+  const relinka = _createRelinka({
     reporters: options.reporters || [new BrowserReporter({})],
     ...options
   });
-  return relinka2;
+  return relinka;
 }
-export const relinka = createRelinka();
-export default relinka;
+export const relinkaBrowser = createRelinka();
+export default relinkaBrowser;

package/dist-npm/components/modes/shared.d.ts

@@ -1,5 +1,5 @@
 export { LogLevels, LogTypes } from "../../components/levels/levels.js";
-export { Relinka } from "../../components/relinka/relinka.js";
+export { RelinkaInterface } from "../../components/relinka/relinka.js";
 export type * from "../../types/mod.js";
 export type { RelinkaInstance } from "../../components/relinka/relinka.js";
 export type { LogLevel, LogType } from "../../components/levels/levels.js";

package/dist-npm/components/modes/shared.js

@@ -1,2 +1,2 @@
 export { LogLevels, LogTypes } from "../../components/levels/levels.js";
-export { Relinka } from "../../components/relinka/relinka.js";
+export { RelinkaInterface } from "../../components/relinka/relinka.js";

package/dist-npm/components/relinka/logger.d.ts

@@ -0,0 +1,12 @@
+export type MessageKind = "log" | "info" | "warn" | "error" | "success";
+export type VerboseKind = `${MessageKind}-verbose`;
+export type AllKinds = MessageKind | VerboseKind;
+export type MessageConfig = {
+    type: "M_INFO" | "M_ERROR";
+    titleColor?: "retroGradient" | "viceGradient" | "yellowBright";
+    titleTypography?: "bold";
+    contentColor?: "dim";
+    contentTypography?: "italic";
+};
+export declare const relinka: (kind: AllKinds, title: string, content?: string, hint?: string) => void;
+export declare const throwError: (error: unknown) => never;

package/dist-npm/components/relinka/logger.js

@@ -0,0 +1,52 @@
+import { msg } from "../../main.js";
+const verboseLogging = false;
+const MESSAGE_CONFIGS = {
+  log: {
+    type: "M_INFO",
+    titleColor: "retroGradient",
+    titleTypography: "bold"
+  },
+  info: {
+    type: "M_INFO",
+    titleColor: "retroGradient",
+    titleTypography: "bold"
+  },
+  success: {
+    type: "M_INFO",
+    titleColor: "viceGradient",
+    titleTypography: "bold"
+  },
+  warn: {
+    type: "M_ERROR",
+    titleColor: "yellowBright",
+    titleTypography: "bold"
+  },
+  error: {
+    type: "M_ERROR",
+    titleColor: "yellowBright",
+    titleTypography: "bold"
+  }
+};
+export const relinka = (kind, title, content, hint) => {
+  const isVerbose = kind.endsWith("-verbose");
+  const baseKind = isVerbose ? kind.replace("-verbose", "") : kind;
+  if (isVerbose && !verboseLogging) {
+    return;
+  }
+  const config = MESSAGE_CONFIGS[baseKind];
+  msg({
+    ...config,
+    title: isVerbose ? `[debug] ${title}` : title,
+    content: content ?? "",
+    contentColor: "dim",
+    contentTypography: "italic",
+    hint: hint ?? ""
+  });
+};
+export const throwError = (error) => {
+  msg({
+    type: "M_ERROR",
+    title: error instanceof Error ? `\u{1F914} Failed to set up the project: ${error.message}` : "\u{1F914} An unknown error occurred."
+  });
+  process.exit(1);
+};

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

@@ -0,0 +1,21 @@
+import type { RelinkaOptions } from "../../types/mod.js";
+import type { RelinkaInstance } from "./relinka.js";
+export * from "../../components/modes/shared.js";
+/**
+ * Factory function to create a new Relinka instance tailored for use in different environments.
+ * It automatically adjusts logging levels based on environment variables and execution context.
+ *
+ * @param {Partial<RelinkaOptions & { fancy: boolean }>} [options={}] - Optional configuration options. See {@link RelinkaOptions}.
+ * @returns {RelinkaInstance} A new Relinka instance with configurations based on the given options and the execution environment.
+ */
+export declare function createRelinka(options?: Partial<RelinkaOptions & {
+    fancy: boolean;
+}>): RelinkaInstance;
+/**
+ * A default instance of Relinka, created and configured for immediate use.
+ * This instance is configured based on the execution environment and the options provided.
+ *
+ * @type {RelinkaInstance} relinka - The default Relinka instance, ready to use.
+ */
+export declare const relinkaInstance: RelinkaInstance;
+export default relinkaInstance;

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

@@ -0,0 +1,34 @@
+import { isDebug, isTest, isCI } from "std-env";
+import { LogLevels } from "../levels/levels.js";
+import { BasicReporter } from "../reporters/basic.js";
+import { FancyReporter } from "../reporters/fancy.js";
+import { createRelinka as _createRelinka } from "./relinka.js";
+export * from "../../components/modes/shared.js";
+export function createRelinka(options = {}) {
+  let level = _getDefaultLogLevel();
+  if (process.env["RELINKA_LEVEL"]) {
+    level = Number.parseInt(process.env["RELINKA_LEVEL"]) ?? level;
+  }
+  const relinka = _createRelinka({
+    level,
+    defaults: { level },
+    stdout: process.stdout,
+    stderr: process.stderr,
+    reporters: options.reporters || [
+      options.fancy ?? !(isCI || isTest) ? new FancyReporter() : new BasicReporter()
+    ],
+    ...options
+  });
+  return relinka;
+}
+function _getDefaultLogLevel() {
+  if (isDebug) {
+    return LogLevels.debug;
+  }
+  if (isTest) {
+    return LogLevels.warn;
+  }
+  return LogLevels.info;
+}
+export const relinkaInstance = createRelinka();
+export default relinkaInstance;

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

@@ -1,6 +1,12 @@
 import type { LogType } from "../../components/levels/levels.js";
 import type { RelinkaReporter, InputLogObject, LogObject, RelinkaOptions } from "../../types/mod.js";
-export declare class Relinka {
+/**
+ * Relinka class for logging management with support for pause/resume, mocking and customizable reporting.
+ * Provides flexible logging capabilities including level-based logging, custom reporters and integration options.
+ *
+ * @class Relinka
+ */
+export declare class RelinkaInterface {
     options: RelinkaOptions;
     _lastLog: {
         serialized?: string;
@@ -9,34 +15,126 @@ export declare class Relinka {
         time?: Date;
         timeout?: ReturnType<typeof setTimeout>;
     };
+    _paused: boolean;
+    _queue: any[];
     _mockFn?: RelinkaOptions["mockFn"];
-        constructor(options?: Partial<RelinkaOptions>);
-        get level(): any;
-        set level(level: any);
-        create(options: Partial<RelinkaOptions>): RelinkaInstance;
-        withDefaults(defaults: InputLogObject): RelinkaInstance;
-        withTag(tag: string): RelinkaInstance;
-        addReporter(reporter: RelinkaReporter): this;
-        removeReporter(reporter: RelinkaReporter): any;
-        setReporters(reporters: RelinkaReporter[]): this;
+    /**
+     * Creates an instance of Relinka with specified options or defaults.
+     *
+     * @param {Partial<RelinkaOptions>} [options={}] - Configuration options for the Relinka instance.
+     */
+    constructor(options?: Partial<RelinkaOptions>);
+    /**
+     * Gets the current log level of the Relinka instance.
+     *
+     * @returns {number} The current log level.
+     */
+    get level(): any;
+    /**
+     * Sets the minimum log level that will be output by the instance.
+     *
+     * @param {number} level - The new log level to set.
+     */
+    set level(level: any);
+    /**
+     * Creates a new instance of Relinka, inheriting options from the current instance, with possible overrides.
+     *
+     * @param {Partial<RelinkaOptions>} options - Optional overrides for the new instance. See {@link RelinkaOptions}.
+     * @returns {RelinkaInstance} A new Relinka instance. See {@link RelinkaInstance}.
+     */
+    create(options: Partial<RelinkaOptions>): RelinkaInstance;
+    /**
+     * Creates a new Relinka instance with the specified default log object properties.
+     *
+     * @param {InputLogObject} defaults - Default properties to include in any log from the new instance. See {@link InputLogObject}.
+     * @returns {RelinkaInstance} A new Relinka instance. See {@link RelinkaInstance}.
+     */
+    withDefaults(defaults: InputLogObject): RelinkaInstance;
+    /**
+     * Creates a new Relinka instance with a specified tag, which will be included in every log.
+     *
+     * @param {string} tag - The tag to include in each log of the new instance.
+     * @returns {RelinkaInstance} A new Relinka instance. See {@link RelinkaInstance}.
+     */
+    withTag(tag: string): RelinkaInstance;
+    /**
+     * Adds a custom reporter to the Relinka instance.
+     * Reporters will be called for each log message, depending on their implementation and log level.
+     *
+     * @param {RelinkaReporter} reporter - The reporter to add. See {@link RelinkaReporter}.
+     * @returns {Relinka} The current Relinka instance.
+     */
+    addReporter(reporter: RelinkaReporter): this;
+    /**
+     * Removes a custom reporter from the Relinka instance.
+     * If no reporter is specified, all reporters will be removed.
+     *
+     * @param {RelinkaReporter} reporter - The reporter to remove. See {@link RelinkaReporter}.
+     * @returns {Relinka} The current Relinka instance.
+     */
+    removeReporter(reporter: RelinkaReporter): any;
+    /**
+     * Replaces all reporters of the Relinka instance with the specified array of reporters.
+     *
+     * @param {RelinkaReporter[]} reporters - The new reporters to set. See {@link RelinkaReporter}.
+     * @returns {Relinka} The current Relinka instance.
+     */
+    setReporters(reporters: RelinkaReporter[]): this;
     wrapAll(): void;
     restoreAll(): void;
-        wrapConsole(): void;
-        restoreConsole(): void;
-        wrapStd(): void;
+    /**
+     * Overrides console methods with Relinka logging methods for consistent logging.
+     */
+    wrapConsole(): void;
+    /**
+     * Restores the original console methods, removing Relinka overrides.
+     */
+    restoreConsole(): void;
+    /**
+     * Overrides standard output and error streams to redirect them through RelinkaInterface.
+     */
+    wrapStd(): void;
     _wrapStream(stream: NodeJS.WriteStream | undefined, type: LogType): void;
-        restoreStd(): void;
+    /**
+     * Restores the original standard output and error streams, removing the Relinka redirection.
+     */
+    restoreStd(): void;
     _restoreStream(stream?: NodeJS.WriteStream): void;
-        pauseLogs(): void;
-        resumeLogs(): void;
-        mockTypes(mockFn?: RelinkaOptions["mockFn"]): void;
-    _wrapLogFn(defaults: InputLogObject, isRaw?: boolean): (...args: any[]) => false | undefined;
-    _logFn(defaults: InputLogObject, args: any[], isRaw?: boolean): false | undefined;
+    /**
+     * Clears the internal state of the Relinka instance.
+     * This will reset any throttling, last log data, clear any queued logs,
+     * and optionally clear the actual console.
+     *
+     * @param {boolean} clearConsole - Whether to clear the actual console. Defaults to false.
+     */
+    clear(clearConsole?: boolean): void;
+    /**
+     * Pauses logging, queues incoming logs until resumed.
+     */
+    pauseLogs(): void;
+    /**
+     * Resumes logging, processing any queued logs.
+     */
+    resumeLogs(): void;
+    /**
+     * Replaces logging methods with mocks if a mock function is provided.
+     *
+     * @param {RelinkaOptions["mockFn"]} mockFn - The function to use for mocking logging methods. See {@link RelinkaOptions["mockFn"]}.
+     */
+    mockTypes(mockFn?: RelinkaOptions["mockFn"]): void;
+    _wrapLogFn(defaults: InputLogObject, isRaw?: boolean): (...args: any[]) => boolean;
+    _logFn(defaults: InputLogObject, args: any[], isRaw?: boolean): boolean;
     _log(logObj: LogObject): void;
 }
 export type LogFn = {
     (message: InputLogObject | any, ...args: any[]): void;
     raw: (...args: any[]) => void;
 };
-export type RelinkaInstance = Relinka & Record<LogType, LogFn>;
+export type RelinkaInstance = RelinkaInterface & Record<LogType, LogFn>;
+/**
+ * Utility for creating a new Relinka instance with optional configuration.
+ *
+ * @param {Partial<RelinkaOptions>} [options={}] - Optional configuration options for the new Relinka instance. See {@link RelinkaOptions}.
+ * @returns {RelinkaInstance} A new instance of RelinkaInterface. See {@link RelinkaInstance}.
+ */
 export declare function createRelinka(options?: Partial<RelinkaOptions>): RelinkaInstance;