@reliverse/relinka 1.6.0 → 2.2.7

package/dist/mod.js

@@ -0,0 +1,182 @@
+import { re } from "@reliverse/relico";
+const textEncoder = new TextEncoder();
+const LOG_COLORS = {
+  log: re.white,
+  error: re.red,
+  fatal: re.red,
+  warn: re.yellow,
+  info: re.blue,
+  success: re.green,
+  debug: re.gray,
+  box: re.white
+};
+const LOG_SYMBOLS = {
+  log: "\u2502  ",
+  error: "\u2716  ",
+  fatal: "\u2620  ",
+  warn: "\u26A0  ",
+  info: "\u25A0  ",
+  success: "\u2713  ",
+  debug: "\u2731  ",
+  box: ""
+};
+let writeLock = Promise.resolve();
+const formatMessage = (...args) => {
+  const len = args.length;
+  if (len === 0) return "";
+  if (len === 1) return String(args[0]);
+  return args.map(String).join(" ");
+};
+const createPrefixedMessage = (level, message) => {
+  const symbol = LOG_SYMBOLS[level];
+  if (symbol === "") return message;
+  return symbol + message;
+};
+const formatBox = (message) => {
+  const lines = message.split("\n");
+  const lineCount = lines.length;
+  if (lineCount === 0) {
+    return "\u250C\u2500\u2500\u2510\n\u2502  \u2502\n\u2514\u2500\u2500\u2518\n";
+  }
+  let maxWidth = 0;
+  for (let i = 0; i < lineCount; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    const len = line.length;
+    if (len > maxWidth) maxWidth = len;
+  }
+  const padding = 2;
+  const width = maxWidth + padding * 2;
+  const horizontal = "\u2500".repeat(width);
+  const top = `\u250C${horizontal}\u2510
+`;
+  const bottom = `\u2514${horizontal}\u2518
+`;
+  const leftPadding = " ".repeat(padding);
+  const rightPadding = " ".repeat(padding);
+  if (maxWidth === 0) {
+    return `${top}\u2502${" ".repeat(width)}\u2502
+${bottom}`;
+  }
+  let content = "";
+  for (let i = 0; i < lineCount; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    const padded = line.padEnd(maxWidth);
+    content += `\u2502${leftPadding}${padded}${rightPadding}\u2502
+`;
+  }
+  return `${top}${content}${bottom}`;
+};
+const writeAsync = async (text, isError = false) => {
+  const encoded = textEncoder.encode(`${text}
+`);
+  const stream = isError ? Bun.stderr : Bun.stdout;
+  writeLock = writeLock.then(async () => {
+    await Bun.write(stream, encoded);
+  });
+};
+const writeSync = (text, isError = false) => {
+  const encoded = textEncoder.encode(`${text}
+`);
+  (isError ? process.stderr : process.stdout).write(encoded);
+};
+const writeColoredAsync = (text, color, isError = false) => {
+  const coloredText = color(text);
+  return writeAsync(coloredText, isError);
+};
+const writeColoredSync = (text, color, isError = false) => {
+  const coloredText = color(text);
+  writeSync(coloredText, isError);
+};
+function createLogMethod(level, isAsync, isError = false) {
+  const color = LOG_COLORS[level];
+  const isBox = level === "box";
+  if (isAsync) {
+    return (...args) => {
+      const message = formatMessage(...args);
+      const formattedMessage = isBox ? formatBox(message) : createPrefixedMessage(level, message);
+      return writeColoredAsync(formattedMessage, color, isError);
+    };
+  }
+  return (...args) => {
+    const message = formatMessage(...args);
+    const formattedMessage = isBox ? formatBox(message) : createPrefixedMessage(level, message);
+    writeColoredSync(formattedMessage, color, isError);
+  };
+}
+function createRawMethod(isAsync) {
+  if (isAsync) {
+    return (...args) => {
+      const message = formatMessage(...args);
+      return writeAsync(message);
+    };
+  }
+  return (...args) => {
+    const message = formatMessage(...args);
+    writeSync(message);
+  };
+}
+const createCallableLogger = (methods) => {
+  const callable = ((level, ...args) => {
+    const method = methods[level];
+    if (method) {
+      method(...args);
+      return;
+    }
+    methods.log(...args);
+  });
+  callable.log = methods.log;
+  callable.error = methods.error;
+  callable.fatal = methods.fatal;
+  callable.warn = methods.warn;
+  callable.info = methods.info;
+  callable.success = methods.success;
+  callable.debug = methods.debug;
+  callable.box = methods.box;
+  callable.raw = methods.raw;
+  return callable;
+};
+const createCallableLoggerAsync = (methods) => {
+  const callable = ((level, ...args) => {
+    const method = methods[level];
+    if (method) {
+      return method(...args);
+    }
+    return methods.log(...args);
+  });
+  callable.log = methods.log;
+  callable.error = methods.error;
+  callable.fatal = methods.fatal;
+  callable.warn = methods.warn;
+  callable.info = methods.info;
+  callable.success = methods.success;
+  callable.debug = methods.debug;
+  callable.box = methods.box;
+  callable.raw = methods.raw;
+  return callable;
+};
+const loggerMethods = {
+  log: createLogMethod("log", false),
+  error: createLogMethod("error", false, true),
+  fatal: createLogMethod("fatal", false, true),
+  warn: createLogMethod("warn", false),
+  info: createLogMethod("info", false),
+  success: createLogMethod("success", false),
+  debug: createLogMethod("debug", false),
+  box: createLogMethod("box", false),
+  raw: createRawMethod(false)
+};
+const relinkaMethods = {
+  log: createLogMethod("log", true),
+  error: createLogMethod("error", true, true),
+  fatal: createLogMethod("fatal", true, true),
+  warn: createLogMethod("warn", true),
+  info: createLogMethod("info", true),
+  success: createLogMethod("success", true),
+  debug: createLogMethod("debug", true),
+  box: createLogMethod("box", true),
+  raw: createRawMethod(true)
+};
+export const logger = createCallableLogger(loggerMethods);
+export const relinka = createCallableLoggerAsync(relinkaMethods);

package/package.json

@@ -1,45 +1,24 @@
 {
-  "dependencies": {
-    "@reliverse/pathkit": "^1.3.4",
-    "@reliverse/relico": "^1.3.8",
-    "@reliverse/relifso": "^1.4.5",
-    "c12": "^3.2.0"
-  },
-  "description": "@reliverse/relinka is a modern, minimal logging library that actually feels right. It's not just pretty output — it's a system: smart formatting, file-safe logging, runtime config support, and a fatal mode built for developers who care about correctness.",
-  "homepage": "https://docs.reliverse.org/cli",
-  "license": "MIT",
   "name": "@reliverse/relinka",
+  "version": "2.2.7",
+  "private": false,
   "type": "module",
-  "version": "1.6.0",
-  "keywords": [
-    "logger",
-    "consola",
-    "console",
-    "elegant",
-    "clack",
-    "cli",
-    "error",
-    "format",
-    "prompt",
-    "reliverse",
-    "reporter",
-    "stacktrace",
-    "unified",
-    "universal"
-  ],
-  "devDependencies": {},
+  "description": "@reliverse/relinka is a modern and lightweight logging library.",
   "exports": {
-    ".": "./bin/mod.js"
+    ".": {
+      "types": "./dist/mod.d.ts",
+      "default": "./dist/mod.js"
+    }
+  },
+  "dependencies": {
+    "@reliverse/relico": "2.2.7"
   },
-  "files": [
-    "bin",
-    "package.json",
-    "README.md",
-    "LICENSE"
-  ],
-  "main": "./bin/mod.js",
-  "module": "./bin/mod.js",
   "publishConfig": {
     "access": "public"
-  }
-}
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "license": "MIT"
+}

package/LICENSE

@@ -1,21 +0,0 @@
-# MIT License
-
-Copyright (c) Nazar Kornienko (blefnk), Reliverse
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/bin/alias.d.ts

@@ -1,8 +0,0 @@
-/**
- * Alias exports for the relinka logger
- * Provides convenient aliases for common logging needs
- */
-import { relinka } from "./impl.js";
-export { relinka as log, relinka as logger };
-export declare function message(msg: string, ...args: unknown[]): void;
-export declare function step(msg: string, ...args: unknown[]): void;

package/bin/alias.js

@@ -1,8 +0,0 @@
-import { relinka } from "./impl.js";
-export { relinka as log, relinka as logger };
-export function message(msg, ...args) {
-  relinka.log(msg, ...args);
-}
-export function step(msg, ...args) {
-  relinka.step(msg, ...args);
-}

package/bin/impl.d.ts

@@ -1,50 +0,0 @@
-import { type LogLevel, type RelinkaConfig, type RelinkaConfigOptions, type RelinkaFunction } from "./setup";
-/** Promise resolved once the user's config (if any) is merged. */
-export declare const loadRelinkaConfig: Promise<RelinkaConfig>;
-/**
- * Enhanced relinkaConfig function that accepts options
- */
-export declare function relinkaConfig(options?: RelinkaConfigOptions): Promise<RelinkaConfig>;
-/**
- * Shuts down the logger, flushing all buffers and clearing timers.
- * As Relinka user - call this at the end of your program to prevent hanging.
- */
-export declare function relinkaShutdown(): Promise<void>;
-/**
- * Flushes all log buffers to disk. Used before process exit or on demand.
- */
-export declare function flushAllLogBuffers(): Promise<void>;
-/**
- * If something truly impossible happened, log + throw.
- */
-export declare function shouldNeverHappen(message: string, ...args: unknown[]): never;
-/**
- * Truncates a string to a specified length, adding "…" if truncated.
- */
-export declare function truncateString(msg: string, maxLength?: number): string;
-/**
- * Exhaustiveness check. If we land here, we missed a union case.
- */
-export declare function casesHandled(unexpectedCase: never): never;
-/**
- * Logs a message synchronously using the current config.
- * If type === "fatal", logs a fatal error and throws (never returns).
- *
- * Can be used in two ways:
- * - relinka("level", message, ...args) - traditional syntax
- * - relinka.level(message, ...args) - method syntax
- */
-export declare const relinka: RelinkaFunction;
-/**
- * Logs a message asynchronously, waiting for the config to be fully loaded.
- * If type === "fatal", logs a fatal error and throws (never returns).
- */
-export declare function relinkaAsync(type: LogLevel, message: string, ...args: unknown[]): Promise<void>;
-/**
- * Type helper for user config files.
- */
-export declare function defineConfig(config: Partial<RelinkaConfig>): Partial<RelinkaConfig>;
-/**
- * Simple box formatting function
- */
-export declare function formatBox(text: string): string;