@reliverse/relinka 1.5.5 → 1.5.7

package/bin/impl.js

@@ -1,8 +1,8 @@
+import os from "node:os";
 import path from "@reliverse/pathkit";
 import { re } from "@reliverse/relico";
 import fs from "@reliverse/relifso";
 import { loadConfig } from "c12";
-import os from "node:os";
 import {
   DEFAULT_RELINKA_CONFIG,
   ENABLE_DEV_DEBUG,
@@ -43,13 +43,9 @@ export async function relinkaConfig(options = {}) {
       await fs.ensureDir(path.dirname(logFilePath));
       await fs.writeFile(logFilePath, "");
       if (isVerboseEnabled(config)) {
-        console.log(`[Relinka Fresh Log] Cleared log file: ${logFilePath}`);
       }
-    } catch (err) {
+    } catch (_err) {
       if (isVerboseEnabled(config)) {
-        console.error(
-          `[Relinka Fresh Log Error] Failed to clear log file: ${err instanceof Error ? err.message : String(err)}`
-        );
       }
     }
   }
@@ -77,14 +73,10 @@ async function initializeConfig() {
       if (result.config?.relinka) {
         currentConfig = { ...DEFAULT_RELINKA_CONFIG, ...result.config.relinka };
         if (ENABLE_DEV_DEBUG) {
-          console.log("[Dev Debug] Using relinka config from dler config");
         }
       } else {
         currentConfig = { ...DEFAULT_RELINKA_CONFIG };
         if (ENABLE_DEV_DEBUG) {
-          console.log(
-            "[Dev Debug] No relinka config in dler config, using defaults"
-          );
         }
       }
     } catch {
@@ -99,21 +91,14 @@ async function initializeConfig() {
       });
       currentConfig = relinkaResult.config;
       if (ENABLE_DEV_DEBUG) {
-        console.log(
-          "[Dev Debug] Dler config loading failed, using separate relinka config"
-        );
       }
     }
     isConfigInitialized = true;
     resolveRelinkaConfig?.(currentConfig);
     resolveRelinkaConfig = void 0;
     if (ENABLE_DEV_DEBUG) {
-      console.log("[Dev Debug] Final configuration:", currentConfig);
     }
-  } catch (err) {
-    console.error(
-      `[Relinka Config Error] Failed to load config: ${err instanceof Error ? err.message : String(err)}`
-    );
+  } catch (_err) {
     currentConfig = { ...DEFAULT_RELINKA_CONFIG };
     isConfigInitialized = true;
     resolveRelinkaConfig?.(currentConfig);
@@ -140,10 +125,7 @@ function setupBufferFlushTimer() {
     }
   }
 }
-initializeConfig().catch((err) => {
-  console.error(
-    `[Relinka Config Error] Unhandled error: ${err instanceof Error ? err.message : String(err)}`
-  );
+initializeConfig().catch((_err) => {
   if (!isConfigInitialized) {
     currentConfig = { ...DEFAULT_RELINKA_CONFIG };
     isConfigInitialized = true;
@@ -191,7 +173,9 @@ function getDateString(date = /* @__PURE__ */ new Date()) {
   ).padStart(2, "0")}`;
 }
 function getTimestamp(config) {
-  if (!config.timestamp?.enabled) return "";
+  if (!config.timestamp?.enabled) {
+    return "";
+  }
   const now = /* @__PURE__ */ new Date();
   const format = config.timestamp?.format || "YYYY-MM-DD HH:mm:ss.SSS";
   return format.replace("YYYY", String(now.getFullYear())).replace("MM", String(now.getMonth() + 1).padStart(2, "0")).replace("DD", String(now.getDate()).padStart(2, "0")).replace("HH", String(now.getHours()).padStart(2, "0")).replace("mm", String(now.getMinutes()).padStart(2, "0")).replace("ss", String(now.getSeconds()).padStart(2, "0")).replace("SSS", String(now.getMilliseconds()).padStart(3, "0"));
@@ -245,7 +229,9 @@ function getLevelStyle(config, level) {
   };
 }
 function formatDetails(details) {
-  if (details === void 0) return "";
+  if (details === void 0) {
+    return "";
+  }
   if (details instanceof Error) {
     return `
 Stack Trace: ${details.stack || details.message}`;
@@ -315,84 +301,74 @@ async function getLogFilesSortedByDate(config) {
                 logFiles.push(path.join(file, subFile));
               }
             }
-          } catch (subDirErr) {
+          } catch (_subDirErr) {
             if (isVerboseEnabled(config)) {
-              console.error(
-                `[Relinka FS Debug] Error reading subdirectory ${filePath}: ${subDirErr instanceof Error ? subDirErr.message : String(subDirErr)}`
-              );
             }
           }
         }
-      } catch (err) {
+      } catch (_err) {
         if (isVerboseEnabled(config)) {
-          console.error(
-            `[Relinka FS Debug] Error accessing ${filePath}: ${err instanceof Error ? err.message : String(err)}`
-          );
         }
       }
     }
-    if (logFiles.length === 0) return [];
-    const fileInfoPromises = logFiles.map(
-      async (fileName) => {
-        const filePath = path.join(logDirectoryPath, fileName);
-        try {
-          const stats = await fs.stat(filePath);
-          if (stats.isFile()) {
-            return { path: filePath, mtime: stats.mtime.getTime() };
-          }
-          return null;
-        } catch (err) {
-          if (isVerboseEnabled(config)) {
-            console.error(
-              `[Relinka FS Debug] Error reading stats for ${filePath}: ${err instanceof Error ? err.message : String(err)}`
-            );
-          }
-          return null;
+    if (logFiles.length === 0) {
+      return [];
+    }
+    const fileInfoPromises = logFiles.map(async (fileName) => {
+      const filePath = path.join(logDirectoryPath, fileName);
+      try {
+        const stats = await fs.stat(filePath);
+        if (stats.isFile()) {
+          return { path: filePath, mtime: stats.mtime.getTime() };
+        }
+        return null;
+      } catch (_err) {
+        if (isVerboseEnabled(config)) {
         }
+        return null;
       }
-    );
+    });
     const logFileInfos = (await Promise.all(fileInfoPromises)).filter(Boolean);
     return logFileInfos.sort((a, b) => b.mtime - a.mtime);
-  } catch (readErr) {
+  } catch (_readErr) {
     if (isVerboseEnabled(config)) {
-      console.error(
-        `[Relinka FS Error] Failed reading directory ${logDirectoryPath}: ${readErr instanceof Error ? readErr.message : String(readErr)}`
-      );
     }
     return [];
   }
 }
 async function deleteFiles(filePaths, config) {
-  if (filePaths.length === 0) return;
-  const results = await Promise.allSettled(
-    filePaths.map((filePath) => fs.unlink(filePath))
-  );
+  if (filePaths.length === 0) {
+    return;
+  }
+  const results = await Promise.allSettled(filePaths.map((filePath) => fs.unlink(filePath)));
   const errors = results.map(
     (result, index) => result.status === "rejected" ? { path: filePaths[index], error: result.reason } : null
   ).filter(Boolean);
   if (errors.length > 0 && isVerboseEnabled(config)) {
-    console.error(
-      `[Relinka FS Error] Failed to delete ${errors.length} log files:`,
-      errors.map(
-        (e) => `${e?.path}: ${e?.error instanceof Error ? e.error.message : String(e?.error)}`
-      ).join(", ")
-    );
   }
 }
 let sigintHandler;
 let sigtermHandler;
 export async function relinkaShutdown() {
-  activeTimers.forEach((timer) => clearTimeout(timer));
+  activeTimers.forEach((timer) => {
+    clearTimeout(timer);
+  });
   activeTimers.length = 0;
   cleanupScheduled = false;
-  if (sigintHandler) process.off("SIGINT", sigintHandler);
-  if (sigtermHandler) process.off("SIGTERM", sigtermHandler);
+  if (sigintHandler) {
+    process.off("SIGINT", sigintHandler);
+  }
+  if (sigtermHandler) {
+    process.off("SIGTERM", sigtermHandler);
+  }
   await flushAllLogBuffers();
 }
 async function cleanupOldLogFiles(config) {
   const maxFiles = getMaxLogFiles(config);
   const cleanupInterval = getCleanupInterval(config);
-  if (!shouldSaveLogs(config) || maxFiles <= 0) return;
+  if (!shouldSaveLogs(config) || maxFiles <= 0) {
+    return;
+  }
   const now = Date.now();
   if (now - lastCleanupTime < cleanupInterval) {
     if (!cleanupScheduled) {
@@ -402,12 +378,11 @@ async function cleanupOldLogFiles(config) {
         cleanupScheduled = false;
         lastCleanupTime = Date.now();
         const index = activeTimers.indexOf(timer);
-        if (index !== -1) activeTimers.splice(index, 1);
-        cleanupOldLogFiles(config).catch((err) => {
+        if (index !== -1) {
+          activeTimers.splice(index, 1);
+        }
+        cleanupOldLogFiles(config).catch((_err) => {
           if (isVerboseEnabled(config)) {
-            console.error(
-              `[Relinka Delayed Cleanup Error] ${err instanceof Error ? err.message : String(err)}`
-            );
           }
         });
       }, delay);
@@ -424,17 +399,11 @@ async function cleanupOldLogFiles(config) {
       if (filesToDelete.length > 0) {
         await deleteFiles(filesToDelete, config);
         if (isVerboseEnabled(config)) {
-          console.log(
-            `[Relinka Cleanup] Deleted ${filesToDelete.length} old log file(s). Kept ${maxFiles}.`
-          );
         }
       }
     }
-  } catch (err) {
+  } catch (_err) {
     if (isVerboseEnabled(config)) {
-      console.error(
-        `[Relinka Cleanup Error] Failed during log cleanup: ${err instanceof Error ? err.message : String(err)}`
-      );
     }
   }
 }
@@ -443,11 +412,8 @@ async function appendToLogFileImmediate(config, absoluteLogFilePath, logMessage)
     await fs.ensureDir(path.dirname(absoluteLogFilePath));
     await fs.appendFile(absoluteLogFilePath, `${logMessage}
 `);
-  } catch (err) {
+  } catch (_err) {
     if (isVerboseEnabled(config)) {
-      console.error(
-        `[Relinka File Error] Failed to write to log file ${absoluteLogFilePath}: ${err instanceof Error ? err.message : String(err)}`
-      );
     }
   }
 }
@@ -483,11 +449,8 @@ function flushLogBuffer(config, filePath) {
   buffer.lastFlush = Date.now();
   logWriteChain = logWriteChain.then(() => {
     return appendToLogFileImmediate(config, filePath, content);
-  }).catch((err) => {
+  }).catch((_err) => {
     if (isVerboseEnabled(config)) {
-      console.error(
-        `[Relinka Buffer Flush Error] Failed to flush buffer for ${filePath}: ${err instanceof Error ? err.message : String(err)}`
-      );
     }
   });
   return logWriteChain;
@@ -497,9 +460,7 @@ function queueLogWrite(config, absoluteLogFilePath, logMessage) {
 }
 export async function flushAllLogBuffers() {
   const filePaths = Array.from(logBuffers.keys());
-  await Promise.all(
-    filePaths.map((path2) => flushLogBuffer(currentConfig, path2))
-  );
+  await Promise.all(filePaths.map((path2) => flushLogBuffer(currentConfig, path2)));
 }
 function internalFatalLogAndThrow(message, ...args) {
   const formatted = formatLogMessage(currentConfig, "fatal", message, args);
@@ -510,10 +471,7 @@ function internalFatalLogAndThrow(message, ...args) {
       fs.ensureDirSync(path.dirname(absoluteLogFilePath));
       fs.appendFileSync(absoluteLogFilePath, `${formatted}
 `);
-    } catch (err) {
-      console.error(
-        `[Relinka Fatal File Error] Failed to write fatal error: ${err instanceof Error ? err.message : String(err)}`
-      );
+    } catch (_err) {
     }
   }
   if (isDevEnv()) {
@@ -525,7 +483,9 @@ export function shouldNeverHappen(message, ...args) {
   return internalFatalLogAndThrow(message, ...args);
 }
 export function truncateString(msg, maxLength = 100) {
-  if (!msg || msg.length <= maxLength) return msg;
+  if (!msg || msg.length <= maxLength) {
+    return msg;
+  }
   return `${msg.slice(0, maxLength - 1)}\u2026`;
 }
 export function casesHandled(unexpectedCase) {
@@ -535,7 +495,9 @@ export function casesHandled(unexpectedCase) {
   );
 }
 function registerExitHandlers() {
-  if (globalThis[EXIT_GUARD]) return;
+  if (globalThis[EXIT_GUARD]) {
+    return;
+  }
   globalThis[EXIT_GUARD] = true;
   process.once("beforeExit", () => {
     void flushAllLogBuffers();
@@ -550,13 +512,11 @@ function registerExitHandlers() {
   process.once("SIGTERM", sigtermHandler);
 }
 registerExitHandlers();
-export const relinka = (type, message, ...args) => {
+export const relinka = ((type, message, ...args) => {
   if (type === "clear") {
-    console.clear();
     return;
   }
   if (message === "") {
-    console.log();
     return;
   }
   const levelName = type.toLowerCase();
@@ -567,35 +527,22 @@ export const relinka = (type, message, ...args) => {
     return;
   }
   const details = args.length > 1 ? args : args[0];
-  const formatted = formatLogMessage(
-    currentConfig,
-    levelName,
-    message,
-    details
-  );
+  const formatted = formatLogMessage(currentConfig, levelName, message, details);
   logToConsole(currentConfig, levelName, formatted);
   if (shouldSaveLogs(currentConfig) && levelName !== "fatal") {
     const absoluteLogFilePath = getLogFilePath(currentConfig);
-    queueLogWrite(currentConfig, absoluteLogFilePath, formatted).catch(
-      (err) => {
-        if (isVerboseEnabled(currentConfig)) {
-          console.error(
-            `[Relinka File Error] Failed to write log line: ${err instanceof Error ? err.message : String(err)}`
-          );
-        }
+    queueLogWrite(currentConfig, absoluteLogFilePath, formatted).catch((_err) => {
+      if (isVerboseEnabled(currentConfig)) {
       }
-    );
+    });
     if (getMaxLogFiles(currentConfig) > 0) {
-      cleanupOldLogFiles(currentConfig).catch((err) => {
+      cleanupOldLogFiles(currentConfig).catch((_err) => {
         if (isVerboseEnabled(currentConfig)) {
-          console.error(
-            `[Relinka Cleanup Error] ${err instanceof Error ? err.message : String(err)}`
-          );
         }
       });
     }
   }
-};
+});
 relinka.error = (message, ...args) => relinka("error", message, ...args);
 relinka.fatal = (message, ...args) => relinka("fatal", message, ...args);
 relinka.info = (message, ...args) => relinka("info", message, ...args);
@@ -611,7 +558,6 @@ relinka.clear = () => relinka("clear", "");
 relinka.message = (message, ...args) => relinka("message", message, ...args);
 export async function relinkaAsync(type, message, ...args) {
   if (message === "") {
-    console.log();
     return;
   }
   await relinkaConfig({ supportFreshLogFile: false });
@@ -623,12 +569,7 @@ export async function relinkaAsync(type, message, ...args) {
     return;
   }
   const details = args.length > 1 ? args : args[0];
-  const formatted = formatLogMessage(
-    currentConfig,
-    levelName,
-    message,
-    details
-  );
+  const formatted = formatLogMessage(currentConfig, levelName, message, details);
   logToConsole(currentConfig, levelName, formatted);
   if (shouldSaveLogs(currentConfig)) {
     const absoluteLogFilePath = getLogFilePath(currentConfig);
@@ -637,11 +578,8 @@ export async function relinkaAsync(type, message, ...args) {
       if (getMaxLogFiles(currentConfig) > 0) {
         await cleanupOldLogFiles(currentConfig);
       }
-    } catch (err) {
+    } catch (_err) {
       if (isVerboseEnabled(currentConfig)) {
-        console.error(
-          `[Relinka File Async Error] Error during file logging/cleanup: ${err instanceof Error ? err.message : String(err)}`
-        );
       }
     }
   }

package/bin/mod.d.ts

@@ -1,3 +1,3 @@
-export { message, step, log, logger } from "./alias.js";
-export type { RelinkaDirsConfig, LogLevelConfig, LogLevelsConfig, LogLevel, RelinkaConfig, LogFileInfo, RelinkaFunction, RelinkaConfigOptions, } from "./setup.js";
-export { loadRelinkaConfig, relinkaConfig, relinkaShutdown, flushAllLogBuffers, shouldNeverHappen, truncateString, casesHandled, relinka, relinkaAsync, defineConfig, formatBox, } from "./impl.js";
+export { log, logger, message, step } from "./alias.js";
+export { casesHandled, defineConfig, flushAllLogBuffers, formatBox, loadRelinkaConfig, relinka, relinkaAsync, relinkaConfig, relinkaShutdown, shouldNeverHappen, truncateString, } from "./impl.js";
+export type { LogFileInfo, LogLevel, LogLevelConfig, LogLevelsConfig, RelinkaConfig, RelinkaConfigOptions, RelinkaDirsConfig, RelinkaFunction, } from "./setup.js";

package/bin/mod.js

@@ -1,14 +1,14 @@
-export { message, step, log, logger } from "./alias.js";
+export { log, logger, message, step } from "./alias.js";
 export {
+  casesHandled,
+  defineConfig,
+  flushAllLogBuffers,
+  formatBox,
   loadRelinkaConfig,
+  relinka,
+  relinkaAsync,
   relinkaConfig,
   relinkaShutdown,
-  flushAllLogBuffers,
   shouldNeverHappen,
-  truncateString,
-  casesHandled,
-  relinka,
-  relinkaAsync,
-  defineConfig,
-  formatBox
+  truncateString
 } from "./impl.js";

package/bin/setup.d.ts

@@ -1,4 +1,4 @@
-import type { DefaultColorKeys } from "@reliverse/relico";
+import type { DefaultColorKeys } from "./types";
 export declare const ENABLE_DEV_DEBUG = false;
 export declare const EXIT_GUARD: unique symbol;
 /** Configuration for directory-related settings. */

package/bin/types.d.ts

@@ -0,0 +1,2 @@
+import type { ColorName, ReStyleKey } from "@reliverse/relico";
+export type DefaultColorKeys = ColorName | ReStyleKey;

package/package.json

@@ -1,16 +1,16 @@
 {
   "dependencies": {
     "@reliverse/pathkit": "^1.3.4",
-    "@reliverse/relico": "^1.1.2",
+    "@reliverse/relico": "^1.3.5",
     "@reliverse/relifso": "^1.4.5",
-    "c12": "^3.0.4"
+    "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",
+  "homepage": "https://docs.reliverse.org/cli",
   "license": "MIT",
   "name": "@reliverse/relinka",
   "type": "module",
-  "version": "1.5.5",
+  "version": "1.5.7",
   "keywords": [
     "logger",
     "consola",