@reliverse/relinka 1.3.4 → 1.3.6

package/bin/relinka-impl/impl-mod.js

@@ -0,0 +1,454 @@
+import { re } from "@reliverse/relico";
+import { loadConfig } from "c12";
+import fs from "fs-extra";
+import { createJiti } from "jiti";
+import path from "pathe";
+const DEFAULT_RELINKA_CONFIG = {
+  debug: false,
+  dirs: {
+    dailyLogs: false,
+    logDir: ".reliverse",
+    maxLogFiles: 0,
+    specialDirs: {
+      distDirNames: ["dist", "dist-jsr", "dist-npm", "dist-libs"],
+      useParentConfigInDist: true
+    }
+  },
+  disableColors: false,
+  logFilePath: "relinka.log",
+  saveLogsToFile: false,
+  withTimestamp: false
+};
+const SUPPORTED_EXTENSIONS = [".ts", ".js", ".mjs", ".cjs", ".json"];
+function isDebugEnabled(config) {
+  return config?.debug ?? DEFAULT_RELINKA_CONFIG.debug;
+}
+function isColorEnabled(config) {
+  return !(config?.disableColors ?? DEFAULT_RELINKA_CONFIG.disableColors);
+}
+function getLogDir(config) {
+  return config?.dirs?.logDir ?? DEFAULT_RELINKA_CONFIG.dirs.logDir;
+}
+function isDailyLogsEnabled(config) {
+  return config?.dirs?.dailyLogs ?? DEFAULT_RELINKA_CONFIG.dirs.dailyLogs;
+}
+function shouldSaveLogs(config) {
+  return config?.saveLogsToFile ?? DEFAULT_RELINKA_CONFIG.saveLogsToFile;
+}
+function getMaxLogFiles(config) {
+  return config?.dirs?.maxLogFiles ?? DEFAULT_RELINKA_CONFIG.dirs.maxLogFiles;
+}
+function getBaseLogName(config) {
+  return config?.logFilePath ?? DEFAULT_RELINKA_CONFIG.logFilePath;
+}
+const getEnvBoolean = (envVarName) => {
+  const value = process.env[envVarName];
+  if (value === void 0 || value === "") return void 0;
+  const lowerValue = value.toLowerCase().trim();
+  return !["0", "false"].includes(lowerValue);
+};
+const getEnvString = (envVarName) => {
+  return process.env[envVarName] || void 0;
+};
+const getEnvNumber = (envVarName) => {
+  const value = process.env[envVarName];
+  if (value === void 0) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+};
+const getEnvOverrides = () => {
+  const overrides = {};
+  const dirsOverride = {};
+  const specialDirsOverride = {};
+  const debug = getEnvBoolean("RELINKA_DEBUG");
+  if (debug !== void 0) overrides.debug = debug;
+  const withTimestamp = getEnvBoolean("RELINKA_TIMESTAMP");
+  if (withTimestamp !== void 0) overrides.withTimestamp = withTimestamp;
+  const disableColors = getEnvBoolean("RELINKA_DISABLE_COLORS");
+  if (disableColors !== void 0) overrides.disableColors = disableColors;
+  const saveLogsToFile = getEnvBoolean("RELINKA_SAVE_LOGS");
+  if (saveLogsToFile !== void 0) overrides.saveLogsToFile = saveLogsToFile;
+  const logFilePath = getEnvString("RELINKA_LOG_FILE");
+  if (logFilePath !== void 0) overrides.logFilePath = logFilePath;
+  const logDir = getEnvString("RELINKA_LOG_DIR");
+  if (logDir !== void 0) dirsOverride.logDir = logDir;
+  const dailyLogs = getEnvBoolean("RELINKA_DAILY_LOGS");
+  if (dailyLogs !== void 0) dirsOverride.dailyLogs = dailyLogs;
+  const maxLogFiles = getEnvNumber("RELINKA_MAX_LOG_FILES");
+  if (maxLogFiles !== void 0) dirsOverride.maxLogFiles = maxLogFiles;
+  const useParentConfig = getEnvBoolean("RELINKA_USE_PARENT_CONFIG");
+  if (useParentConfig !== void 0) {
+    specialDirsOverride.useParentConfigInDist = useParentConfig;
+  }
+  if (Object.keys(specialDirsOverride).length > 0) {
+    dirsOverride.specialDirs = specialDirsOverride;
+  }
+  if (Object.keys(dirsOverride).length > 0) {
+    overrides.dirs = dirsOverride;
+  }
+  return overrides;
+};
+let currentConfig = { ...DEFAULT_RELINKA_CONFIG };
+let isConfigInitialized = false;
+let resolveConfigPromise;
+export const configPromise = new Promise((resolve) => {
+  resolveConfigPromise = resolve;
+});
+const findConfigFile = (basePath) => {
+  for (const ext of SUPPORTED_EXTENSIONS) {
+    const filePath = basePath + ext;
+    if (fs.existsSync(filePath)) {
+      return filePath;
+    }
+  }
+  return void 0;
+};
+const initializeConfig = async () => {
+  try {
+    const envOverrides = getEnvOverrides();
+    const projectRoot = process.cwd();
+    const reliverseDir = path.resolve(projectRoot, ".reliverse");
+    const configName = "relinka";
+    const resolveConfig = async (id, options) => {
+      if (id !== configName) {
+        return null;
+      }
+      const effectiveCwd = options.cwd || projectRoot;
+      const _jitiRequire = createJiti(effectiveCwd, options.jitiOptions);
+      const loadAndExtract = async (filePath) => {
+        try {
+          const loadedModule = await _jitiRequire.import(filePath);
+          const configData = loadedModule.default || loadedModule;
+          return configData;
+        } catch (error) {
+          console.error(
+            `[Relinka Config Error] Failed to load or parse config from ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+          );
+          return null;
+        }
+      };
+      const reliverseBasePath = path.resolve(reliverseDir, configName);
+      const reliverseConfigFile = findConfigFile(reliverseBasePath);
+      if (reliverseConfigFile) {
+        const config = await loadAndExtract(reliverseConfigFile);
+        if (config !== null) {
+          return { config, source: reliverseConfigFile };
+        }
+      }
+      const rootBasePath = path.resolve(effectiveCwd, configName);
+      const rootConfigFile = findConfigFile(rootBasePath);
+      if (rootConfigFile) {
+        const config = await loadAndExtract(rootConfigFile);
+        if (config !== null) {
+          return { config, source: rootConfigFile };
+        }
+      }
+      return null;
+    };
+    const loadedConfigResult = await loadConfig({
+      name: configName,
+      cwd: projectRoot,
+      resolve: resolveConfig,
+      packageJson: "relinka",
+      dotenv: true,
+      defaults: DEFAULT_RELINKA_CONFIG,
+      overrides: envOverrides
+    });
+    currentConfig = loadedConfigResult.config ?? { ...DEFAULT_RELINKA_CONFIG };
+    isConfigInitialized = true;
+    const customResolvedLayer = loadedConfigResult.layers?.find(
+      (layer) => layer.source?.includes(configName)
+    );
+    if (customResolvedLayer?.source) {
+      console.log(
+        `[Relinka Config] Loaded main configuration from: ${path.relative(
+          projectRoot,
+          customResolvedLayer.source
+        )}`
+      );
+    } else {
+      const pkgJsonLayer = loadedConfigResult.layers?.find(
+        (layer) => layer.source?.endsWith("package.json")
+      );
+      if (pkgJsonLayer?.config) {
+        console.log("[Relinka Config] Loaded configuration from package.json.");
+      } else {
+        console.log(
+          "[Relinka Config] No config file or package.json entry found. Using defaults and environment variables."
+        );
+      }
+    }
+    if (isDebugEnabled(currentConfig)) {
+      console.log(
+        "[Relinka Config Debug] Final configuration object:",
+        JSON.stringify(currentConfig, null, 2)
+      );
+      console.log(
+        "[Relinka Config Debug] Resolved layers:",
+        loadedConfigResult.layers?.map((l) => ({
+          config: l.config ? "[Object]" : null,
+          source: l.source ? path.relative(projectRoot, l.source) : void 0,
+          meta: l.meta
+        }))
+      );
+    }
+    if (resolveConfigPromise) {
+      resolveConfigPromise(currentConfig);
+    }
+    return currentConfig;
+  } catch (error) {
+    console.error(
+      `[Relinka Config Error] Failed during configuration loading process: ${error instanceof Error ? error.message : String(error)}`
+    );
+    currentConfig = { ...DEFAULT_RELINKA_CONFIG };
+    isConfigInitialized = true;
+    if (resolveConfigPromise) {
+      resolveConfigPromise(currentConfig);
+    }
+    return currentConfig;
+  }
+};
+initializeConfig().catch((err) => {
+  console.error(
+    `[Relinka Config Error] Unhandled error during initial configuration load: ${err instanceof Error ? err.message : String(err)}`
+  );
+  if (!isConfigInitialized) {
+    currentConfig = { ...DEFAULT_RELINKA_CONFIG };
+    isConfigInitialized = true;
+    if (resolveConfigPromise) {
+      resolveConfigPromise(currentConfig);
+    }
+  }
+});
+const getTimestamp = (config) => {
+  if (!config?.withTimestamp) return "";
+  const now = /* @__PURE__ */ new Date();
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(
+    2,
+    "0"
+  )}-${String(now.getDate()).padStart(2, "0")} ${String(
+    now.getHours()
+  ).padStart(2, "0")}:${String(now.getMinutes()).padStart(
+    2,
+    "0"
+  )}:${String(now.getSeconds()).padStart(2, "0")}.${String(
+    now.getMilliseconds()
+  ).padStart(3, "0")}`;
+};
+const getLogFilePath = (config) => {
+  const logDir = getLogDir(config);
+  const daily = isDailyLogsEnabled(config);
+  let finalLogName = getBaseLogName(config);
+  if (daily) {
+    const now = /* @__PURE__ */ new Date();
+    const datePrefix = `${now.getFullYear()}-${String(
+      now.getMonth() + 1
+    ).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}-`;
+    finalLogName = datePrefix + finalLogName;
+  }
+  if (finalLogName && !finalLogName.endsWith(".log")) {
+    finalLogName += ".log";
+  }
+  const effectiveLogName = finalLogName || "relinka.log";
+  return path.resolve(process.cwd(), logDir, effectiveLogName);
+};
+const formatLogMessage = (config, level, msg, details) => {
+  const timestamp = getTimestamp(config);
+  let detailsStr = "";
+  if (details !== void 0) {
+    if (details instanceof Error) {
+      detailsStr = `
+Stack Trace: ${details.stack || details.message}`;
+    } else if (typeof details === "object" && details !== null) {
+      try {
+        detailsStr = ` ${JSON.stringify(details)}`;
+      } catch {
+        detailsStr = " [object Object]";
+      }
+    } else {
+      detailsStr = ` ${String(details)}`;
+    }
+  }
+  const paddedLevel = level.padEnd(7, " ");
+  return timestamp ? `[${timestamp}] ${paddedLevel} ${msg}${detailsStr}` : `${paddedLevel} ${msg}${detailsStr}`;
+};
+const logToConsole = (config, level, formattedMessage) => {
+  if (!isColorEnabled(config)) {
+    switch (level) {
+      case "ERROR":
+        console.error(formattedMessage);
+        break;
+      default:
+        console.log(formattedMessage);
+    }
+  } else {
+    switch (level) {
+      case "ERROR":
+        console.error(re.redBright(formattedMessage));
+        break;
+      case "WARN":
+        console.warn(re.yellowBright(formattedMessage));
+        break;
+      case "SUCCESS":
+        console.log(re.greenBright(formattedMessage));
+        break;
+      case "INFO":
+        console.log(re.cyanBright(formattedMessage));
+        break;
+      default:
+        console.log(re.dim(formattedMessage));
+    }
+  }
+};
+const getLogFilesSortedByDate = async (config) => {
+  const logDirectoryPath = path.resolve(process.cwd(), getLogDir(config));
+  const debugEnabled = isDebugEnabled(config);
+  try {
+    if (!await fs.pathExists(logDirectoryPath)) {
+      if (debugEnabled) {
+        console.log(
+          `[Relinka FS Debug] Log directory does not exist: ${logDirectoryPath}`
+        );
+      }
+      return [];
+    }
+    const files = await fs.readdir(logDirectoryPath);
+    const logFilesPromises = files.filter((file) => file.endsWith(".log")).map(async (file) => {
+      const filePath = path.join(logDirectoryPath, file);
+      try {
+        const stats = await fs.stat(filePath);
+        return stats.isFile() ? { path: filePath, mtime: stats.mtime.getTime() } : null;
+      } catch (statError) {
+        if (debugEnabled) {
+          console.error(
+            `[Relinka FS Debug] Error stating file ${filePath}: ${statError instanceof Error ? statError.message : String(statError)}`
+          );
+        }
+        return null;
+      }
+    });
+    const logFiles = (await Promise.all(logFilesPromises)).filter(
+      (fileInfo) => Boolean(fileInfo)
+    );
+    return logFiles.sort((a, b) => b.mtime - a.mtime);
+  } catch (readDirError) {
+    if (debugEnabled) {
+      console.error(
+        `[Relinka FS Error] Error reading log directory ${logDirectoryPath}: ${readDirError instanceof Error ? readDirError.message : String(readDirError)}`
+      );
+    }
+    return [];
+  }
+};
+const deleteFiles = async (filePaths, config) => {
+  const debugEnabled = isDebugEnabled(config);
+  const deletePromises = filePaths.map(async (filePath) => {
+    try {
+      await fs.unlink(filePath);
+    } catch (unlinkErr) {
+      if (debugEnabled) {
+        console.error(
+          `[Relinka FS Error] Failed to delete log file ${filePath}: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`
+        );
+      }
+    }
+  });
+  await Promise.all(deletePromises);
+};
+const cleanupOldLogFiles = async (config) => {
+  const maxFiles = getMaxLogFiles(config);
+  const debugEnabled = isDebugEnabled(config);
+  if (!shouldSaveLogs(config) || maxFiles <= 0) return;
+  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 (debugEnabled) {
+          console.log(
+            `[Relinka Cleanup] Deleted ${filesToDelete.length} old log file(s). Kept ${maxFiles}.`
+          );
+        }
+      }
+    }
+  } catch (err) {
+    if (debugEnabled) {
+      console.error(
+        `[Relinka Cleanup Error] Failed during log cleanup: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+};
+const appendToLogFile = async (config, absoluteLogFilePath, logMessage) => {
+  const debugEnabled = isDebugEnabled(config);
+  try {
+    await fs.ensureDir(path.dirname(absoluteLogFilePath));
+    await fs.appendFile(absoluteLogFilePath, `${logMessage}
+`);
+  } catch (err) {
+    if (debugEnabled) {
+      console.error(
+        `[Relinka File Error] Failed to write to log file ${absoluteLogFilePath}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+};
+export const relinka = (type, message, ...args) => {
+  const configToUse = currentConfig;
+  if (message === "") {
+    console.log();
+    return;
+  }
+  const logLevelLabel = type === "verbose" ? "DEBUG" : type.toUpperCase();
+  if (logLevelLabel === "DEBUG" && !isDebugEnabled(configToUse)) {
+    return;
+  }
+  const details = args.length > 0 ? args.length === 1 ? args[0] : args : void 0;
+  const formattedMessage = formatLogMessage(
+    configToUse,
+    logLevelLabel,
+    message,
+    details
+  );
+  logToConsole(configToUse, logLevelLabel, formattedMessage);
+};
+export const relinkaAsync = async (type, message, ...args) => {
+  const loadedConfig = await configPromise;
+  if (message === "") {
+    console.log();
+    return;
+  }
+  const logLevelLabel = type === "verbose" ? "DEBUG" : type.toUpperCase();
+  if (logLevelLabel === "DEBUG" && !isDebugEnabled(loadedConfig)) {
+    return;
+  }
+  const details = args.length > 0 ? args.length === 1 ? args[0] : args : void 0;
+  const formattedMessage = formatLogMessage(
+    loadedConfig,
+    logLevelLabel,
+    message,
+    details
+  );
+  logToConsole(loadedConfig, logLevelLabel, formattedMessage);
+  if (shouldSaveLogs(loadedConfig)) {
+    const absoluteLogFilePath = getLogFilePath(loadedConfig);
+    try {
+      await appendToLogFile(
+        loadedConfig,
+        absoluteLogFilePath,
+        formattedMessage
+      );
+      await cleanupOldLogFiles(loadedConfig);
+    } catch (err) {
+      if (isDebugEnabled(loadedConfig)) {
+        console.error(
+          `[Relinka File Async Error] Error during file logging/cleanup process: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+};
+export const defineConfig = (config) => {
+  return config;
+};

package/bin/{libs/core/core-impl/deprecated/types/mod.d.ts → relinka-types.d.ts}

@@ -1,10 +1,54 @@
 /// <reference types="node" />
-import type { LogLevelDeprecated, LogTypeDeprecated } from "../components/levels/levels.js";
-export type RelinkaOptions = {
+/** Configuration for special directory handling. */
+export type RelinkaSpecialDirsConfig = {
+    distDirNames?: string[];
+    useParentConfigInDist?: boolean;
+};
+/** Configuration for directory-related settings. */
+export type RelinkaDirsConfig = {
+    dailyLogs?: boolean;
+    logDir?: string;
+    maxLogFiles?: number;
+    specialDirs?: RelinkaSpecialDirsConfig;
+};
+/**
+ * Configuration options for the Relinka logger.
+ * All properties are optional to allow for partial configuration.
+ * Defaults will be applied during initialization.
+ */
+export type RelinkaConfig = {
+    debug?: boolean;
+    dirs?: RelinkaDirsConfig;
+    disableColors?: boolean;
+    logFilePath?: string;
+    saveLogsToFile?: boolean;
+    withTimestamp?: boolean;
+};
+/** Represents information about a log file for cleanup purposes. */
+export type LogFileInfo = {
+    path: string;
+    mtime: number;
+};
+/** Log level types used by the logger. */
+export type LogLevel = "error" | "info" | "success" | "verbose" | "warn";
+/**
+ * Defines the level of logs as specific numbers or special number types.
+ *
+ * @type {0 | 1 | 2 | 3 | 4 | 5 | (number & {})} LogLevelDeprecated - Represents the log level.
+ * @default 0 - Represents the default log level.
+ */
+export type LogLevelDeprecated = 0 | 1 | 2 | 3 | 4 | 5 | (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"} LogTypeDeprecated - Represents the specific type of log message.
+ */
+export type LogTypeDeprecated = "silent" | "fatal" | "error" | "warn" | "log" | "info" | "success" | "fail" | "ready" | "start" | "box" | "debug" | "trace" | "verbose";
+export type RelinkaOptionsDeprecated = {
     /**
-     * An array of RelinkaReporter instances used to handle and output log messages.
+     * An array of RelinkaReporterDeprecated instances used to handle and output log messages.
      */
-    reporters: RelinkaReporter[];
+    reporters: RelinkaReporterDeprecated[];
     /**
      * A record mapping LogTypeDeprecated to InputLogObject, defining the log configuration for each log type.
      * See {@link LogTypeDeprecated} and {@link InputLogObject}.
@@ -138,13 +182,13 @@ export type LogObject = {
      */
     [key: string]: unknown;
 } & InputLogObject;
-export type RelinkaReporter = {
+export type RelinkaReporterDeprecated = {
     /**
      * Defines how a log message is processed and displayed by this reporter.
      * @param logObj The LogObject containing the log information to process. See {@link LogObject}.
-     * @param ctx An object containing context information such as options. See {@link RelinkaOptions}.
+     * @param ctx An object containing context information such as options. See {@link RelinkaOptionsDeprecated}.
      */
     log: (logObj: LogObject, ctx: {
-        options: RelinkaOptions;
+        options: RelinkaOptionsDeprecated;
     }) => void;
 };

package/package.json

@@ -1,88 +1,21 @@
 {
+  "description": "@reliverse/relinka is a powerful logger for your terminal.",
+  "license": "MIT",
+  "name": "@reliverse/relinka",
+  "type": "module",
+  "version": "1.3.6",
   "dependencies": {
-    "@figliolia/chalk-animation": "^1.0.4",
     "@reliverse/relico": "^1.0.2",
     "@reliverse/runtime": "^1.0.3",
-    "@sinclair/typebox": "^0.34.31",
-    "ansi-diff-stream": "^1.2.1",
-    "ansi-escapes": "^7.0.0",
-    "chalk": "^5.4.1",
-    "cli-spinners": "^3.2.0",
-    "cli-styles": "^1.0.0",
-    "cli-width": "^4.1.0",
-    "confbox": "^0.2.1",
+    "c12": "^3.0.2",
     "defu": "^6.1.4",
-    "destr": "^2.0.3",
-    "detect-package-manager": "^3.0.2",
-    "external-editor": "^3.1.0",
-    "fast-glob": "^3.3.3",
-    "figlet": "^1.8.0",
     "fs-extra": "^11.3.0",
-    "get-pixels": "^3.3.3",
-    "globby": "^14.1.0",
-    "gradient-string": "^3.0.0",
-    "kleur": "^4.1.5",
-    "log-update": "^6.1.0",
-    "mri": "^1.2.0",
-    "mute-stream": "^2.0.0",
-    "node-emoji": "^2.2.0",
-    "nypm": "^0.6.0",
-    "ora": "^8.2.0",
     "pathe": "^2.0.3",
-    "precision": "^1.0.1",
-    "seventh": "^0.9.2",
-    "signal-exit": "^4.1.0",
-    "sisteransi": "^1.0.5",
-    "std-env": "^3.8.1",
-    "string-width": "^7.2.0",
-    "strip-ansi": "^7.1.0",
-    "terminal-size": "^4.0.0",
-    "ts-regex-builder": "^1.8.2",
-    "window-size": "^1.1.1",
-    "wrap-ansi": "^9.0.0"
-  },
-  "description": "@reliverse/relinka is a powerful logger for your terminal.",
-  "homepage": "https://docs.reliverse.org",
-  "license": "MIT",
-  "name": "@reliverse/relinka",
-  "type": "module",
-  "version": "1.3.4",
-  "devDependencies": {
-    "@arethetypeswrong/cli": "^0.17.4",
-    "@biomejs/biome": "1.9.4",
-    "@cspell/dict-npm": "^5.1.32",
-    "@eslint/js": "^9.23.0",
-    "@reliverse/relidler-cfg": "^1.1.3",
-    "@stylistic/eslint-plugin": "^4.2.0",
-    "@types/ansi-diff-stream": "^1.2.3",
-    "@types/bun": "^1.2.8",
-    "@types/chalk-animation": "^1.6.3",
-    "@types/figlet": "^1.7.0",
-    "@types/fs-extra": "^11.0.4",
-    "@types/mute-stream": "^0.0.4",
-    "@types/node": "^22.13.16",
-    "@types/sentencer": "^0.2.3",
-    "@types/signal-exit": "^4.0.0",
-    "@types/strip-comments": "^2.0.4",
-    "@types/window-size": "^1.1.4",
-    "c12": "^3.0.2",
-    "citty": "^0.1.6",
-    "eslint": "^9.23.0",
-    "eslint-plugin-no-relative-import-paths": "^1.6.1",
-    "eslint-plugin-perfectionist": "^4.10.1",
-    "execa": "^9.5.2",
-    "jiti": "^2.4.2",
-    "knip": "^5.46.4",
-    "mock-stdin": "^1.0.0",
     "printj": "^1.3.1",
-    "sentencer": "^0.2.1",
-    "strip-comments": "^2.0.1",
-    "tsx": "^4.19.3",
-    "typescript": "^5.8.2",
-    "typescript-eslint": "^8.29.0",
-    "unbuild": "^3.5.0",
-    "vitest": "^3.1.1"
+    "std-env": "^3.8.1",
+    "string-width": "^7.2.0"
   },
+  "devDependencies": {},
   "exports": {
     ".": "./bin/main.js"
   },

package/bin/libs/core/core-impl/deprecated/components/core/core.d.ts

@@ -1 +0,0 @@
-export * from "../modes/shared.js";

package/bin/libs/core/core-impl/deprecated/components/core/core.js

@@ -1 +0,0 @@
-export * from "../modes/shared.js";

package/bin/libs/core/core-impl/deprecated/components/levels/levels.d.ts

@@ -1,26 +0,0 @@
-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 & {})} LogLevelDeprecated - Represents the log level.
- * @default 0 - Represents the default log level.
- */
-export type LogLevelDeprecated = 0 | 1 | 2 | 3 | 4 | 5 | (number & {});
-/**
- * A mapping of `LogTypeDeprecated` to its corresponding numeric log level.
- *
- * @type {Record<LogTypeDeprecated, number>} LogLevelsDeprecated - key-value pairs of log types to their numeric levels. See {@link LogTypeDeprecated}.
- */
-export declare const LogLevelsDeprecated: Record<LogTypeDeprecated, 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"} LogTypeDeprecated - Represents the specific type of log message.
- */
-export type LogTypeDeprecated = "silent" | "fatal" | "error" | "warn" | "log" | "info" | "success" | "fail" | "ready" | "start" | "box" | "debug" | "trace" | "verbose";
-/**
- * Maps `LogTypeDeprecated` to a `Partial<LogObject>`, primarily defining the log level.
- *
- * @type {Record<LogTypeDeprecated, Partial<LogObject>>} LogTypesDeprecated - key-value pairs of log types to partial log objects, specifying log levels. See {@link LogTypeDeprecated} and {@link LogObject}.
- */
-export declare const LogTypesDeprecated: Record<LogTypeDeprecated, Partial<LogObject>>;

package/bin/libs/core/core-impl/deprecated/components/modes/shared.d.ts

@@ -1,3 +0,0 @@
-export { LogLevelsDeprecated, LogTypesDeprecated, } from "../levels/levels.js";
-export type * from "../../types/mod.js";
-export type { LogLevelDeprecated, LogTypeDeprecated, } from "../levels/levels.js";

package/bin/libs/core/core-impl/deprecated/utils/mod.d.ts

@@ -1,3 +0,0 @@
-export * from "./box.js";
-export * from "./deprecatedColors.js";
-export { stripAnsi, centerAlign, rightAlign, leftAlign, align, } from "./string.js";

package/bin/libs/core/core-impl/deprecated/utils/mod.js

@@ -1,9 +0,0 @@
-export * from "./box.js";
-export * from "./deprecatedColors.js";
-export {
-  stripAnsi,
-  centerAlign,
-  rightAlign,
-  leftAlign,
-  align
-} from "./string.js";