@reliverse/relinka 1.6.1 → 2.2.7

package/bin/impl.js

@@ -1,605 +0,0 @@
-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 {
-  DEFAULT_RELINKA_CONFIG,
-  ENABLE_DEV_DEBUG,
-  EXIT_GUARD
-} from "./setup.js";
-function isUnicodeSupported() {
-  if (process.env.TERM_PROGRAM === "vscode" || process.env.WT_SESSION || process.env.TERM_PROGRAM === "iTerm.app" || process.env.TERM_PROGRAM === "hyper" || process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm" || process.env.ConEmuTask === "{cmd::Cmder}" || process.env.TERM === "xterm-256color") {
-    return true;
-  }
-  if (process.platform === "win32") {
-    const osRelease = os.release();
-    const match = /(\d+)\.(\d+)/.exec(osRelease);
-    if (match && Number.parseInt(match[1] ?? "0", 10) >= 10) {
-      return true;
-    }
-    if (process.env.TERM_PROGRAM === "mintty") {
-      return true;
-    }
-    return false;
-  }
-  return true;
-}
-let currentConfig = { ...DEFAULT_RELINKA_CONFIG };
-let isConfigInitialized = false;
-let resolveRelinkaConfig;
-let userTerminalCwd;
-export const loadRelinkaConfig = new Promise((res) => {
-  resolveRelinkaConfig = res;
-});
-export async function relinkaConfig(options = {}) {
-  if (!userTerminalCwd) {
-    userTerminalCwd = process.cwd();
-  }
-  const config = await loadRelinkaConfig;
-  if (options.supportFreshLogFile && isFreshLogFileEnabled(config)) {
-    try {
-      const logFilePath = getLogFilePath(config);
-      await fs.ensureDir(path.dirname(logFilePath));
-      await fs.writeFile(logFilePath, "");
-      if (isVerboseEnabled(config)) {
-      }
-    } catch (_err) {
-      if (isVerboseEnabled(config)) {
-      }
-    }
-  }
-  return config;
-}
-const logBuffers = /* @__PURE__ */ new Map();
-const activeTimers = [];
-let bufferFlushTimer = null;
-let lastCleanupTime = 0;
-let cleanupScheduled = false;
-async function initializeConfig() {
-  try {
-    let result;
-    try {
-      result = await loadConfig({
-        name: "dler",
-        // name: "relinka",
-        cwd: process.cwd(),
-        dotenv: false,
-        packageJson: false,
-        rcFile: false,
-        globalRc: false,
-        defaults: {}
-      });
-      if (result.config?.relinka) {
-        currentConfig = { ...DEFAULT_RELINKA_CONFIG, ...result.config.relinka };
-        if (ENABLE_DEV_DEBUG) {
-        }
-      } else {
-        currentConfig = { ...DEFAULT_RELINKA_CONFIG };
-        if (ENABLE_DEV_DEBUG) {
-        }
-      }
-    } catch {
-      const relinkaResult = await loadConfig({
-        name: "relinka",
-        cwd: process.cwd(),
-        dotenv: false,
-        packageJson: false,
-        rcFile: false,
-        globalRc: false,
-        defaults: DEFAULT_RELINKA_CONFIG
-      });
-      currentConfig = relinkaResult.config;
-      if (ENABLE_DEV_DEBUG) {
-      }
-    }
-    isConfigInitialized = true;
-    resolveRelinkaConfig?.(currentConfig);
-    resolveRelinkaConfig = void 0;
-    if (ENABLE_DEV_DEBUG) {
-    }
-  } catch (_err) {
-    currentConfig = { ...DEFAULT_RELINKA_CONFIG };
-    isConfigInitialized = true;
-    resolveRelinkaConfig?.(currentConfig);
-    resolveRelinkaConfig = void 0;
-  } finally {
-    setupBufferFlushTimer();
-  }
-}
-function setupBufferFlushTimer() {
-  if (bufferFlushTimer) {
-    clearInterval(bufferFlushTimer);
-    activeTimers.splice(activeTimers.indexOf(bufferFlushTimer), 1);
-  }
-  const maxAge = getMaxBufferAge(currentConfig);
-  bufferFlushTimer = setInterval(flushDueBuffers, Math.min(maxAge / 2, 2500));
-  bufferFlushTimer.unref();
-  activeTimers.push(bufferFlushTimer);
-  function flushDueBuffers() {
-    const now = Date.now();
-    for (const [fp, buf] of logBuffers) {
-      if (buf.entries.length && now - buf.lastFlush >= maxAge) {
-        flushLogBuffer(currentConfig, fp).catch(console.error);
-      }
-    }
-  }
-}
-initializeConfig().catch((_err) => {
-  if (!isConfigInitialized) {
-    currentConfig = { ...DEFAULT_RELINKA_CONFIG };
-    isConfigInitialized = true;
-    if (resolveRelinkaConfig) {
-      resolveRelinkaConfig(currentConfig);
-      resolveRelinkaConfig = void 0;
-    }
-    setupBufferFlushTimer();
-  }
-});
-function isVerboseEnabled(config) {
-  return config.verbose ?? DEFAULT_RELINKA_CONFIG.verbose ?? false;
-}
-function isColorEnabled(config) {
-  return !(config.disableColors ?? DEFAULT_RELINKA_CONFIG.disableColors);
-}
-function shouldSaveLogs(config) {
-  return config.saveLogsToFile ?? DEFAULT_RELINKA_CONFIG.saveLogsToFile ?? false;
-}
-function getMaxLogFiles(config) {
-  return config.dirs?.maxLogFiles ?? 0;
-}
-function getBaseLogName(config) {
-  const logFileConfig = config.logFile || DEFAULT_RELINKA_CONFIG.logFile || {};
-  return logFileConfig.outputPath ?? "logs.log";
-}
-function getBufferSize(config) {
-  return config.bufferSize ?? DEFAULT_RELINKA_CONFIG.bufferSize ?? 4096;
-}
-function getMaxBufferAge(config) {
-  return config.maxBufferAge ?? DEFAULT_RELINKA_CONFIG.maxBufferAge ?? 5e3;
-}
-function getCleanupInterval(config) {
-  return config.cleanupInterval ?? DEFAULT_RELINKA_CONFIG.cleanupInterval ?? 1e4;
-}
-function isFreshLogFileEnabled(config) {
-  return config.logFile?.freshLogFile ?? DEFAULT_RELINKA_CONFIG.logFile?.freshLogFile ?? false;
-}
-function isDevEnv() {
-  return process.env.NODE_ENV === "development";
-}
-function getDateString(date = /* @__PURE__ */ new Date()) {
-  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(
-    date.getDate()
-  ).padStart(2, "0")}`;
-}
-function getTimestamp(config) {
-  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"));
-}
-function getLogFilePath(config) {
-  const logFileConfig = config.logFile || DEFAULT_RELINKA_CONFIG.logFile || {};
-  const nameWithDate = logFileConfig.nameWithDate || "disable";
-  const outputPath = getBaseLogName(config);
-  const dir = path.dirname(outputPath);
-  let filename = path.basename(outputPath);
-  if (nameWithDate !== "disable") {
-    const dateString = getDateString();
-    if (nameWithDate === "append-before") {
-      filename = `${dateString}-${filename}`;
-    } else if (nameWithDate === "append-after") {
-      const nameWithoutExt = filename.replace(/\.log$/, "");
-      filename = `${nameWithoutExt}-${dateString}.log`;
-    }
-  }
-  if (filename && !filename.endsWith(".log")) {
-    filename += ".log";
-  }
-  const effectiveFilename = filename || "logs.log";
-  const finalPath = dir === "." ? effectiveFilename : path.join(dir, effectiveFilename);
-  const baseCwd = userTerminalCwd || process.cwd();
-  return path.resolve(baseCwd, finalPath);
-}
-function getLevelStyle(config, level) {
-  const allLevels = config.levels || DEFAULT_RELINKA_CONFIG.levels || {};
-  const levelConfig = allLevels[level];
-  if (!levelConfig) {
-    return {
-      symbol: `[${level.toUpperCase()}]`,
-      color: "dim",
-      spacing: 3
-    };
-  }
-  if (level === "null") {
-    return {
-      symbol: "",
-      color: levelConfig.color,
-      spacing: 0
-    };
-  }
-  const { symbol, fallbackSymbol, color, spacing } = levelConfig;
-  const effectiveSymbol = isUnicodeSupported() ? symbol : fallbackSymbol || `[${level.toUpperCase()}]`;
-  return {
-    symbol: effectiveSymbol,
-    color,
-    spacing: spacing ?? 3
-  };
-}
-function formatDetails(details) {
-  if (details === void 0) {
-    return "";
-  }
-  if (details instanceof Error) {
-    return `
-Stack Trace: ${details.stack || details.message}`;
-  }
-  if (typeof details === "object" && details !== null) {
-    try {
-      return ` ${JSON.stringify(details, null, 2)}`;
-    } catch {
-      return " [object Object]";
-    }
-  }
-  return ` ${String(details)}`;
-}
-function formatLogMessage(config, level, msg, details) {
-  const timestamp = getTimestamp(config);
-  const detailsStr = formatDetails(details);
-  const { symbol, spacing } = getLevelStyle(config, level);
-  const symbolWithSpaces = symbol ? `${symbol}${" ".repeat(spacing)}` : "";
-  const prefix = timestamp ? `[${timestamp}] ` : "";
-  let content = `${prefix}${symbolWithSpaces}${msg}${detailsStr}`;
-  if (level === "box") {
-    content = formatBox(content);
-  }
-  return content;
-}
-const consoleMethodMap = {
-  error: console.error,
-  fatal: console.error,
-  warn: console.warn,
-  info: console.info,
-  success: console.log,
-  verbose: console.log,
-  log: console.log,
-  internal: console.log,
-  step: console.log,
-  box: console.log,
-  message: console.log,
-  null: console.log
-};
-function logToConsole(config, level, formattedMessage) {
-  if (!isColorEnabled(config)) {
-    const method2 = consoleMethodMap[level] || console.log;
-    method2(formattedMessage);
-    return;
-  }
-  const { color } = getLevelStyle(config, level);
-  const colorFn = re[color] || re.dim;
-  const method = consoleMethodMap[level] || console.log;
-  method(`${colorFn(formattedMessage)}\x1B[0m`);
-}
-async function getLogFilesSortedByDate(config) {
-  const logDirectoryPath = userTerminalCwd || process.cwd();
-  try {
-    const files = await fs.readdir(logDirectoryPath);
-    const logFiles = [];
-    for (const file of files) {
-      const filePath = path.join(logDirectoryPath, file);
-      try {
-        const stats = await fs.stat(filePath);
-        if (stats.isFile() && file.endsWith(".log")) {
-          logFiles.push(file);
-        } else if (stats.isDirectory()) {
-          try {
-            const subFiles = await fs.readdir(filePath);
-            for (const subFile of subFiles) {
-              if (subFile.endsWith(".log")) {
-                logFiles.push(path.join(file, subFile));
-              }
-            }
-          } catch (_subDirErr) {
-            if (isVerboseEnabled(config)) {
-            }
-          }
-        }
-      } catch (_err) {
-        if (isVerboseEnabled(config)) {
-        }
-      }
-    }
-    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(
-      (info) => info !== null
-    );
-    return logFileInfos.sort((a, b) => b.mtime - a.mtime);
-  } catch (_readErr) {
-    if (isVerboseEnabled(config)) {
-    }
-    return [];
-  }
-}
-async function deleteFiles(filePaths, config) {
-  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)) {
-  }
-}
-let sigintHandler;
-let sigtermHandler;
-export async function relinkaShutdown() {
-  activeTimers.forEach((timer) => {
-    clearTimeout(timer);
-  });
-  activeTimers.length = 0;
-  cleanupScheduled = false;
-  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;
-  }
-  const now = Date.now();
-  if (now - lastCleanupTime < cleanupInterval) {
-    if (!cleanupScheduled) {
-      cleanupScheduled = true;
-      const delay = cleanupInterval - (now - lastCleanupTime);
-      const timer = setTimeout(() => {
-        cleanupScheduled = false;
-        lastCleanupTime = Date.now();
-        const index = activeTimers.indexOf(timer);
-        if (index !== -1) {
-          activeTimers.splice(index, 1);
-        }
-        cleanupOldLogFiles(config).catch((_err) => {
-          if (isVerboseEnabled(config)) {
-          }
-        });
-      }, delay);
-      timer.unref();
-      activeTimers.push(timer);
-    }
-    return;
-  }
-  lastCleanupTime = now;
-  try {
-    const sortedLogFiles = await getLogFilesSortedByDate(config);
-    if (sortedLogFiles.length > maxFiles) {
-      const filesToDelete = sortedLogFiles.slice(maxFiles).map((f) => f.path);
-      if (filesToDelete.length > 0) {
-        await deleteFiles(filesToDelete, config);
-        if (isVerboseEnabled(config)) {
-        }
-      }
-    }
-  } catch (_err) {
-    if (isVerboseEnabled(config)) {
-    }
-  }
-}
-async function appendToLogFileImmediate(config, absoluteLogFilePath, logMessage) {
-  try {
-    await fs.ensureDir(path.dirname(absoluteLogFilePath));
-    await fs.appendFile(absoluteLogFilePath, `${logMessage}
-`);
-  } catch (_err) {
-    if (isVerboseEnabled(config)) {
-    }
-  }
-}
-let logWriteChain = Promise.resolve();
-function addToLogBuffer(config, filePath, message) {
-  const bufferSize = getBufferSize(config);
-  let buffer = logBuffers.get(filePath);
-  if (!buffer) {
-    buffer = {
-      filePath,
-      entries: [],
-      size: 0,
-      lastFlush: Date.now()
-    };
-    logBuffers.set(filePath, buffer);
-  }
-  buffer.entries.push(message);
-  buffer.size += message.length + 1;
-  if (buffer.size >= bufferSize) {
-    return flushLogBuffer(config, filePath);
-  }
-  return Promise.resolve();
-}
-function flushLogBuffer(config, filePath) {
-  const buffer = logBuffers.get(filePath);
-  if (!buffer || buffer.entries.length === 0) {
-    return Promise.resolve();
-  }
-  const content = `${buffer.entries.join("\n")}
-`;
-  buffer.entries = [];
-  buffer.size = 0;
-  buffer.lastFlush = Date.now();
-  logWriteChain = logWriteChain.then(() => {
-    return appendToLogFileImmediate(config, filePath, content);
-  }).catch((_err) => {
-    if (isVerboseEnabled(config)) {
-    }
-  });
-  return logWriteChain;
-}
-function queueLogWrite(config, absoluteLogFilePath, logMessage) {
-  return addToLogBuffer(config, absoluteLogFilePath, logMessage);
-}
-export async function flushAllLogBuffers() {
-  const filePaths = Array.from(logBuffers.keys());
-  await Promise.all(filePaths.map((path2) => flushLogBuffer(currentConfig, path2)));
-}
-function internalFatalLogAndThrow(message, ...args) {
-  const formatted = formatLogMessage(currentConfig, "fatal", message, args);
-  logToConsole(currentConfig, "fatal", formatted);
-  if (shouldSaveLogs(currentConfig)) {
-    try {
-      const absoluteLogFilePath = getLogFilePath(currentConfig);
-      fs.ensureDirSync(path.dirname(absoluteLogFilePath));
-      fs.appendFileSync(absoluteLogFilePath, `${formatted}
-`);
-    } catch (_err) {
-    }
-  }
-  if (isDevEnv()) {
-    debugger;
-  }
-  throw new Error(`Fatal error: ${message}`);
-}
-export function shouldNeverHappen(message, ...args) {
-  return internalFatalLogAndThrow(message, ...args);
-}
-export function truncateString(msg, maxLength = 100) {
-  if (!msg || msg.length <= maxLength) {
-    return msg;
-  }
-  return `${msg.slice(0, maxLength - 1)}\u2026`;
-}
-export function casesHandled(unexpectedCase) {
-  debugger;
-  throw new Error(
-    `A case was not handled for value: ${truncateString(String(unexpectedCase ?? "unknown"))}`
-  );
-}
-function registerExitHandlers() {
-  if (globalThis[EXIT_GUARD]) {
-    return;
-  }
-  globalThis[EXIT_GUARD] = true;
-  process.once("beforeExit", () => {
-    void flushAllLogBuffers();
-  });
-  sigintHandler = () => {
-    void flushAllLogBuffers().finally(() => process.exit(0));
-  };
-  sigtermHandler = () => {
-    void flushAllLogBuffers().finally(() => process.exit(0));
-  };
-  process.once("SIGINT", sigintHandler);
-  process.once("SIGTERM", sigtermHandler);
-}
-registerExitHandlers();
-export const relinka = ((type, message, ...args) => {
-  if (type === "clear") {
-    return;
-  }
-  if (message === "") {
-    return;
-  }
-  const levelName = type.toLowerCase();
-  if (levelName === "fatal") {
-    return internalFatalLogAndThrow(message, ...args);
-  }
-  if (levelName === "verbose" && !isVerboseEnabled(currentConfig)) {
-    return;
-  }
-  const details = args.length > 1 ? args : args[0];
-  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)) {
-      }
-    });
-    if (getMaxLogFiles(currentConfig) > 0) {
-      cleanupOldLogFiles(currentConfig).catch((_err) => {
-        if (isVerboseEnabled(currentConfig)) {
-        }
-      });
-    }
-  }
-});
-relinka.error = (message, ...args) => relinka("error", message, ...args);
-relinka.fatal = (message, ...args) => relinka("fatal", message, ...args);
-relinka.info = (message, ...args) => relinka("info", message, ...args);
-relinka.success = (message, ...args) => relinka("success", message, ...args);
-relinka.verbose = (message, ...args) => relinka("verbose", message, ...args);
-relinka.warn = (message, ...args) => relinka("warn", message, ...args);
-relinka.log = (message, ...args) => relinka("log", message, ...args);
-relinka.internal = (message, ...args) => 
-relinka.null = (message, ...args) => relinka("null", message, ...args);
-relinka.step = (message, ...args) => relinka("step", message, ...args);
-relinka.box = (message, ...args) => relinka("box", message, ...args);
-relinka.clear = () => relinka("clear", "");
-relinka.message = (message, ...args) => relinka("message", message, ...args);
-export async function relinkaAsync(type, message, ...args) {
-  if (message === "") {
-    return;
-  }
-  await relinkaConfig({ supportFreshLogFile: false });
-  const levelName = type.toLowerCase();
-  if (levelName === "fatal") {
-    shouldNeverHappen(message, ...args);
-  }
-  if (levelName === "verbose" && !isVerboseEnabled(currentConfig)) {
-    return;
-  }
-  const details = args.length > 1 ? args : args[0];
-  const formatted = formatLogMessage(currentConfig, levelName, message, details);
-  logToConsole(currentConfig, levelName, formatted);
-  if (shouldSaveLogs(currentConfig)) {
-    const absoluteLogFilePath = getLogFilePath(currentConfig);
-    try {
-      await queueLogWrite(currentConfig, absoluteLogFilePath, formatted);
-      if (getMaxLogFiles(currentConfig) > 0) {
-        await cleanupOldLogFiles(currentConfig);
-      }
-    } catch (_err) {
-      if (isVerboseEnabled(currentConfig)) {
-      }
-    }
-  }
-}
-export function defineConfig(config) {
-  return config;
-}
-export function formatBox(text) {
-  const lines = text.split("\n");
-  const maxWidth = Math.max(...lines.map((line) => line.length));
-  const width = maxWidth + 4;
-  const top = `\u250C${"\u2500".repeat(width)}\u2510`;
-  const bottom = `\u2514${"\u2500".repeat(width)}\u2518`;
-  const content = lines.map((line) => {
-    const padding = width - line.length;
-    return `\u2502  ${line}${" ".repeat(padding - 2)}\u2502`;
-  }).join("\n");
-  return `${top}
-${content}
-${bottom}`;
-}

package/bin/mod.d.ts

@@ -1,3 +0,0 @@
-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 +0,0 @@
-export { log, logger, message, step } from "./alias.js";
-export {
-  casesHandled,
-  defineConfig,
-  flushAllLogBuffers,
-  formatBox,
-  loadRelinkaConfig,
-  relinka,
-  relinkaAsync,
-  relinkaConfig,
-  relinkaShutdown,
-  shouldNeverHappen,
-  truncateString
-} from "./impl.js";