@reliverse/relinka 1.3.5 → 1.3.6

package/bin/main.d.ts

@@ -1 +1,22 @@
-export * from "./libs/core/core-main.js";
+export { LogLevelsDeprecated, LogTypesDeprecated, } from "./relinka-impl/deprecated/components/levels/levels.js";
+export { createRelinkaBaseDeprecated, relinkaBasicDeprecated, } from "./relinka-impl/deprecated/components/modes/basic.js";
+export { createRelinkaBrowserDeprecatedDeprecated, relinkaBrowserDeprecated, } from "./relinka-impl/deprecated/components/modes/browser.js";
+export { relinkaDeprecated } from "./relinka-impl/deprecated/components/relinka-deprecated/logger.js";
+export { createRelinkaSharedDeprecated, relinkaInstanceDeprecated, } from "./relinka-impl/deprecated/components/relinka-deprecated/mod.js";
+export type { LogFn, RelinkaInstanceDeprecated, } from "./relinka-impl/deprecated/components/relinka-deprecated/relinka.js";
+export { RelinkaInterface, createRelinkaDeprecated, } from "./relinka-impl/deprecated/components/relinka-deprecated/relinka.js";
+export { BasicReporter } from "./relinka-impl/deprecated/components/reporters/basic.js";
+export { BrowserReporter } from "./relinka-impl/deprecated/components/reporters/browser.js";
+export { TYPE_COLOR_MAP, LEVEL_COLOR_MAP, FancyReporter, } from "./relinka-impl/deprecated/components/reporters/fancy.js";
+export type { BoxBorderStyle, BoxStyle, BoxOpts, } from "./relinka-impl/deprecated/utils/box.js";
+export { box } from "./relinka-impl/deprecated/utils/box.js";
+export type { ColorName, ColorFunction, } from "./relinka-impl/deprecated/utils/deprecatedColors.js";
+export { colors, getColor, colorize, } from "./relinka-impl/deprecated/utils/deprecatedColors.js";
+export { parseStack } from "./relinka-impl/deprecated/utils/error.js";
+export { compileFormat, formatString, } from "./relinka-impl/deprecated/utils/format.js";
+export { isPlainObject, isLogObj, } from "./relinka-impl/deprecated/utils/log.js";
+export { writeStream } from "./relinka-impl/deprecated/utils/stream.js";
+export { stripAnsi, centerAlign, rightAlign, leftAlign, align, } from "./relinka-impl/deprecated/utils/string.js";
+export type { TreeItemObject, TreeItem, TreeOptions, } from "./relinka-impl/deprecated/utils/tree.js";
+export { formatTree } from "./relinka-impl/deprecated/utils/tree.js";
+export { configPromise, relinka, relinkaAsync, defineConfig, } from "./relinka-impl/impl-mod.js";

package/bin/main.js

@@ -1 +1,58 @@
-export * from "./libs/core/core-main.js";
+export {
+  LogLevelsDeprecated,
+  LogTypesDeprecated
+} from "./relinka-impl/deprecated/components/levels/levels.js";
+export {
+  createRelinkaBaseDeprecated,
+  relinkaBasicDeprecated
+} from "./relinka-impl/deprecated/components/modes/basic.js";
+export {
+  createRelinkaBrowserDeprecatedDeprecated,
+  relinkaBrowserDeprecated
+} from "./relinka-impl/deprecated/components/modes/browser.js";
+export { relinkaDeprecated } from "./relinka-impl/deprecated/components/relinka-deprecated/logger.js";
+export {
+  createRelinkaSharedDeprecated,
+  relinkaInstanceDeprecated
+} from "./relinka-impl/deprecated/components/relinka-deprecated/mod.js";
+export {
+  RelinkaInterface,
+  createRelinkaDeprecated
+} from "./relinka-impl/deprecated/components/relinka-deprecated/relinka.js";
+export { BasicReporter } from "./relinka-impl/deprecated/components/reporters/basic.js";
+export { BrowserReporter } from "./relinka-impl/deprecated/components/reporters/browser.js";
+export {
+  TYPE_COLOR_MAP,
+  LEVEL_COLOR_MAP,
+  FancyReporter
+} from "./relinka-impl/deprecated/components/reporters/fancy.js";
+export { box } from "./relinka-impl/deprecated/utils/box.js";
+export {
+  colors,
+  getColor,
+  colorize
+} from "./relinka-impl/deprecated/utils/deprecatedColors.js";
+export { parseStack } from "./relinka-impl/deprecated/utils/error.js";
+export {
+  compileFormat,
+  formatString
+} from "./relinka-impl/deprecated/utils/format.js";
+export {
+  isPlainObject,
+  isLogObj
+} from "./relinka-impl/deprecated/utils/log.js";
+export { writeStream } from "./relinka-impl/deprecated/utils/stream.js";
+export {
+  stripAnsi,
+  centerAlign,
+  rightAlign,
+  leftAlign,
+  align
+} from "./relinka-impl/deprecated/utils/string.js";
+export { formatTree } from "./relinka-impl/deprecated/utils/tree.js";
+export {
+  configPromise,
+  relinka,
+  relinkaAsync,
+  defineConfig
+} from "./relinka-impl/impl-mod.js";

package/bin/relinka-impl/deprecated/components/levels/levels.d.ts

@@ -0,0 +1,13 @@
+import type { LogObject, LogTypeDeprecated } from "../../../../relinka-types.js";
+/**
+ * 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>;
+/**
+ * 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 → relinka-impl}/deprecated/components/modes/basic.d.ts

@@ -1,13 +1,13 @@
 import type { RelinkaInstanceDeprecated } from "../relinka-deprecated/relinka.js";
-import type { RelinkaOptions } from "../../../../core-types.js";
+import type { RelinkaOptionsDeprecated } from "../../../../relinka-types.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}.
+ * @param {Partial<RelinkaOptionsDeprecated & { fancy: boolean }>} [options={}] - Optional configuration options. See {@link RelinkaOptionsDeprecated}.
  * @returns {RelinkaInstanceDeprecated} A new Relinka instance configured with the given options.
  */
-export declare function createRelinkaBaseDeprecated(options?: Partial<RelinkaOptions & {
+export declare function createRelinkaBaseDeprecated(options?: Partial<RelinkaOptionsDeprecated & {
     fancy: boolean;
 }>): RelinkaInstanceDeprecated;
 /**

package/bin/{libs/core/core-impl → relinka-impl}/deprecated/components/modes/browser.d.ts

@@ -1,15 +1,15 @@
-import type { RelinkaOptions } from "../../../../core-types.js";
+import type { RelinkaOptionsDeprecated } from "../../../../relinka-types.js";
 import { type RelinkaInstanceDeprecated } from "../relinka-deprecated/relinka.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}.
+ * @param {Partial<RelinkaOptionsDeprecated>} [options={}] - Optional configuration options.
+ * The options can override the default reporter and prompt behavior. See {@link RelinkaOptionsDeprecated}.
  * @returns {RelinkaInstanceDeprecated} A new Relinka instance optimized for use in browser environments.
  */
-export declare function createRelinkaBrowserDeprecatedDeprecated(options?: Partial<RelinkaOptions>): any;
+export declare function createRelinkaBrowserDeprecatedDeprecated(options?: Partial<RelinkaOptionsDeprecated>): any;
 /**
  * A standard Relinka instance created with browser-specific configurations.
  * This instance can be used throughout a browser-based project.

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

@@ -0,0 +1,2 @@
+export { LogLevelsDeprecated, LogTypesDeprecated, } from "../levels/levels.js";
+export type * from "../../../../relinka-types.js";

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

@@ -1,14 +1,14 @@
-import type { RelinkaOptions } from "../../../../core-types.js";
+import type { RelinkaOptionsDeprecated } from "../../../../relinka-types.js";
 import type { RelinkaInstanceDeprecated } from "./relinka.js";
 export * from "../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}.
+ * @param {Partial<RelinkaOptionsDeprecated & { fancy: boolean }>} [options={}] - Optional configuration options. See {@link RelinkaOptionsDeprecated}.
  * @returns {RelinkaInstanceDeprecated} A new Relinka instance with configurations based on the given options and the execution environment.
  */
-export declare function createRelinkaSharedDeprecated(options?: Partial<RelinkaOptions & {
+export declare function createRelinkaSharedDeprecated(options?: Partial<RelinkaOptionsDeprecated & {
     fancy: boolean;
 }>): RelinkaInstanceDeprecated;
 /**

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

@@ -1,6 +1,6 @@
 /// <reference types="node" />
-import type { LogTypeDeprecated } from "../levels/levels.js";
-import type { InputLogObject, LogObject, RelinkaOptions, RelinkaReporter } from "../../../../core-types.js";
+import type { LogTypeDeprecated } from "../../../../relinka-types.js";
+import type { InputLogObject, LogObject, RelinkaOptionsDeprecated, RelinkaReporterDeprecated } from "../../../../relinka-types.js";
 /**
  * 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.
@@ -8,7 +8,7 @@ import type { InputLogObject, LogObject, RelinkaOptions, RelinkaReporter } from
  * @class Relinka
  */
 export declare class RelinkaInterface {
-    options: RelinkaOptions;
+    options: RelinkaOptionsDeprecated;
     _lastLog: {
         serialized?: string;
         object?: LogObject;
@@ -18,13 +18,13 @@ export declare class RelinkaInterface {
     };
     _paused: boolean;
     _queue: any[];
-    _mockFn?: RelinkaOptions["mockFn"];
+    _mockFn?: RelinkaOptionsDeprecated["mockFn"];
     /**
      * Creates an instance of Relinka with specified options or defaults.
      *
-     * @param {Partial<RelinkaOptions>} [options={}] - Configuration options for the Relinka instance.
+     * @param {Partial<RelinkaOptionsDeprecated>} [options={}] - Configuration options for the Relinka instance.
      */
-    constructor(options?: Partial<RelinkaOptions>);
+    constructor(options?: Partial<RelinkaOptionsDeprecated>);
     /**
      * Gets the current log level of the Relinka instance.
      *
@@ -40,10 +40,10 @@ export declare class RelinkaInterface {
     /**
      * 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}.
+     * @param {Partial<RelinkaOptionsDeprecated>} options - Optional overrides for the new instance. See {@link RelinkaOptionsDeprecated}.
      * @returns {RelinkaInstanceDeprecated} A new Relinka instance. See {@link RelinkaInstanceDeprecated}.
      */
-    create(options: Partial<RelinkaOptions>): RelinkaInstanceDeprecated;
+    create(options: Partial<RelinkaOptionsDeprecated>): RelinkaInstanceDeprecated;
     /**
      * Creates a new Relinka instance with the specified default log object properties.
      *
@@ -62,25 +62,25 @@ export declare class RelinkaInterface {
      * 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}.
+     * @param {RelinkaReporterDeprecated} reporter - The reporter to add. See {@link RelinkaReporterDeprecated}.
      * @returns {Relinka} The current Relinka instance.
      */
-    addReporter(reporter: RelinkaReporter): this;
+    addReporter(reporter: RelinkaReporterDeprecated): 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}.
+     * @param {RelinkaReporterDeprecated} reporter - The reporter to remove. See {@link RelinkaReporterDeprecated}.
      * @returns {Relinka} The current Relinka instance.
      */
-    removeReporter(reporter: RelinkaReporter): any;
+    removeReporter(reporter: RelinkaReporterDeprecated): 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}.
+     * @param {RelinkaReporterDeprecated[]} reporters - The new reporters to set. See {@link RelinkaReporterDeprecated}.
      * @returns {Relinka} The current Relinka instance.
      */
-    setReporters(reporters: RelinkaReporter[]): this;
+    setReporters(reporters: RelinkaReporterDeprecated[]): this;
     wrapAll(): void;
     restoreAll(): void;
     /**
@@ -120,9 +120,9 @@ export declare class RelinkaInterface {
     /**
      * 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"]}.
+     * @param {RelinkaOptionsDeprecated["mockFn"]} mockFn - The function to use for mocking logging methods. See {@link RelinkaOptionsDeprecated["mockFn"]}.
      */
-    mockTypes(mockFn?: RelinkaOptions["mockFn"]): void;
+    mockTypes(mockFn?: RelinkaOptionsDeprecated["mockFn"]): void;
     _wrapLogFn(defaults: InputLogObject, isRaw?: boolean): (...args: any[]) => boolean;
     _logFn(defaults: InputLogObject, args: any[], isRaw?: boolean): boolean;
     _log(logObj: LogObject): void;
@@ -135,7 +135,7 @@ export type RelinkaInstanceDeprecated = RelinkaInterface & Record<LogTypeDepreca
 /**
  * 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}.
+ * @param {Partial<RelinkaOptionsDeprecated>} [options={}] - Optional configuration options for the new Relinka instance. See {@link RelinkaOptionsDeprecated}.
  * @returns {RelinkaInstanceDeprecated} A new instance of RelinkaInterface. See {@link RelinkaInstanceDeprecated}.
  */
-export declare function createRelinkaDeprecated(options?: Partial<RelinkaOptions>): RelinkaInstanceDeprecated;
+export declare function createRelinkaDeprecated(options?: Partial<RelinkaOptionsDeprecated>): RelinkaInstanceDeprecated;

package/bin/{libs/core/core-impl → relinka-impl}/deprecated/components/relinka-deprecated/relinka.js

@@ -11,7 +11,7 @@ export class RelinkaInterface {
   /**
    * Creates an instance of Relinka with specified options or defaults.
    *
-   * @param {Partial<RelinkaOptions>} [options={}] - Configuration options for the Relinka instance.
+   * @param {Partial<RelinkaOptionsDeprecated>} [options={}] - Configuration options for the Relinka instance.
    */
   constructor(options = {}) {
     const types = options.types || LogTypesDeprecated;
@@ -72,7 +72,7 @@ export class RelinkaInterface {
   /**
    * 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}.
+   * @param {Partial<RelinkaOptionsDeprecated>} options - Optional overrides for the new instance. See {@link RelinkaOptionsDeprecated}.
    * @returns {RelinkaInstanceDeprecated} A new Relinka instance. See {@link RelinkaInstanceDeprecated}.
    */
   create(options) {
@@ -115,7 +115,7 @@ export class RelinkaInterface {
    * 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}.
+   * @param {RelinkaReporterDeprecated} reporter - The reporter to add. See {@link RelinkaReporterDeprecated}.
    * @returns {Relinka} The current Relinka instance.
    */
   addReporter(reporter) {
@@ -126,7 +126,7 @@ export class RelinkaInterface {
    * 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}.
+   * @param {RelinkaReporterDeprecated} reporter - The reporter to remove. See {@link RelinkaReporterDeprecated}.
    * @returns {Relinka} The current Relinka instance.
    */
   removeReporter(reporter) {
@@ -143,7 +143,7 @@ export class RelinkaInterface {
   /**
    * Replaces all reporters of the Relinka instance with the specified array of reporters.
    *
-   * @param {RelinkaReporter[]} reporters - The new reporters to set. See {@link RelinkaReporter}.
+   * @param {RelinkaReporterDeprecated[]} reporters - The new reporters to set. See {@link RelinkaReporterDeprecated}.
    * @returns {Relinka} The current Relinka instance.
    */
   setReporters(reporters) {
@@ -250,7 +250,7 @@ export class RelinkaInterface {
   /**
    * 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"]}.
+   * @param {RelinkaOptionsDeprecated["mockFn"]} mockFn - The function to use for mocking logging methods. See {@link RelinkaOptionsDeprecated["mockFn"]}.
    */
   mockTypes(mockFn) {
     const _mockFn = mockFn || this.options.mockFn;

package/bin/relinka-impl/deprecated/components/relinka-deprecated/relinka.test.d.ts

@@ -0,0 +1 @@
+export {};

package/bin/relinka-impl/deprecated/components/relinka-deprecated/relinka.test.js

@@ -0,0 +1,57 @@
+import { describe, test, expect } from "vitest";
+import { createRelinkaDeprecated } from "./relinka.js";
+import {
+  LogLevelsDeprecated
+} from "./mod.js";
+describe("relinka", () => {
+  test("can set level", () => {
+    const relinka = createRelinkaDeprecated();
+    expect(relinka.level).toBe(1);
+    for (let i = 0; i <= 5; i++) {
+      relinka.level = i;
+      expect(relinka.level).toBe(i);
+    }
+  });
+  test("silent log level does't print logs", async () => {
+    const logs = [];
+    const TestReporter = {
+      log(logObj) {
+        logs.push(logObj);
+      }
+    };
+    const relinka = createRelinkaDeprecated({
+      throttle: 100,
+      level: LogLevelsDeprecated.silent,
+      reporters: [TestReporter]
+    });
+    for (let i = 0; i < 10; i++) {
+      relinka.log("SPAM");
+    }
+    await wait(200);
+    expect(logs.length).toBe(0);
+  });
+  test("can see spams without ending log", async () => {
+    const logs = [];
+    const TestReporter = {
+      log(logObj) {
+        logs.push(logObj);
+      }
+    };
+    const relinka = createRelinkaDeprecated({
+      throttle: 100,
+      level: LogLevelsDeprecated.info,
+      reporters: [TestReporter]
+    });
+    for (let i = 0; i < 10; i++) {
+      relinka.log("SPAM");
+    }
+    await wait(300);
+    expect(logs.length).toBe(7);
+    expect(logs.at(-1).args).toEqual(["SPAM", "(repeated 4 times)"]);
+  });
+});
+function wait(delay) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, delay);
+  });
+}

package/bin/{libs/core/core-impl → relinka-impl}/deprecated/components/reporters/basic.d.ts

@@ -1,11 +1,11 @@
-import type { LogObject, RelinkaReporter, FormatOptions, RelinkaOptions } from "../../../../core-types.js";
-export declare class BasicReporter implements RelinkaReporter {
+import type { LogObject, RelinkaReporterDeprecated, FormatOptions, RelinkaOptionsDeprecated } from "../../../../relinka-types.js";
+export declare class BasicReporter implements RelinkaReporterDeprecated {
     formatStack(stack: string): string;
     formatArgs(args: any[], opts: FormatOptions): string;
     formatDate(date: Date, opts: FormatOptions): string;
     filterAndJoin(arr: any[]): string;
     formatLogObj(logObj: LogObject, opts: FormatOptions): string;
     log(logObj: LogObject, ctx: {
-        options: RelinkaOptions;
+        options: RelinkaOptionsDeprecated;
     }): any;
 }

package/bin/{libs/core/core-impl → relinka-impl}/deprecated/components/reporters/browser.d.ts

@@ -1,4 +1,4 @@
-import type { LogObject } from "../../../../core-types.js";
+import type { LogObject } from "../../../../relinka-types.js";
 export declare class BrowserReporter {
     options: any;
     defaultColor: string;

package/bin/{libs/core/core-impl → relinka-impl}/deprecated/components/reporters/fancy.d.ts

@@ -1,5 +1,5 @@
-import type { LogLevelDeprecated, LogTypeDeprecated } from "../levels/levels.js";
-import type { FormatOptions, LogObject } from "../../../../core-types.js";
+import type { LogLevelDeprecated, LogTypeDeprecated } from "../../../../relinka-types.js";
+import type { FormatOptions, LogObject } from "../../../../relinka-types.js";
 import { BasicReporter } from "./basic.js";
 export declare const TYPE_COLOR_MAP: Partial<Record<LogTypeDeprecated, string>>;
 export declare const LEVEL_COLOR_MAP: Partial<Record<LogLevelDeprecated, string>>;

package/bin/relinka-impl/impl-mod.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Promise that resolves when the Relinka config has been loaded and merged
+ * from defaults, environment variables, and optionally config files.
+ */
+export declare const configPromise: Promise<RelinkaConfig>;
+/**
+ * Logs a message synchronously using the current config.
+ * Skips debug-level logs unless `debug` is set to true in the config.
+ */
+export declare const relinka: (type: LogLevel, message: string, ...args: unknown[]) => void;
+/**
+ * Logs a message asynchronously, waiting for the config to be fully loaded.
+ * Also handles file writing and log cleanup if enabled in the config.
+ */
+export declare const relinkaAsync: (type: LogLevel, message: string, ...args: unknown[]) => Promise<void>;
+/**
+ * Type helper for defining configuration in `relinka.config.ts` (or similar).
+ * Provides autocompletion and type checking for the configuration object.
+ */
+export declare const defineConfig: (config: RelinkaConfig) => RelinkaConfig;

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/{types.d.ts → relinka-types.d.ts}

@@ -1,10 +1,54 @@
 /// <reference types="node" />
-import type { LogLevelDeprecated, LogTypeDeprecated } from "./libs/core/core-impl/deprecated/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,38 +1,21 @@
 {
+  "description": "@reliverse/relinka is a powerful logger for your terminal.",
+  "license": "MIT",
+  "name": "@reliverse/relinka",
+  "type": "module",
+  "version": "1.3.6",
   "dependencies": {
     "@reliverse/relico": "^1.0.2",
     "@reliverse/runtime": "^1.0.3",
+    "c12": "^3.0.2",
     "defu": "^6.1.4",
+    "fs-extra": "^11.3.0",
     "pathe": "^2.0.3",
     "printj": "^1.3.1",
     "std-env": "^3.8.1",
     "string-width": "^7.2.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.5",
-  "devDependencies": {
-    "@biomejs/biome": "1.9.4",
-    "@eslint/js": "^9.23.0",
-    "@reliverse/relidler-cfg": "^1.1.3",
-    "@stylistic/eslint-plugin": "^4.2.0",
-    "@total-typescript/ts-reset": "^0.6.1",
-    "@types/bun": "^1.2.8",
-    "@types/node": "^22.13.16",
-    "@types/sentencer": "^0.2.3",
-    "eslint": "^9.23.0",
-    "eslint-plugin-no-relative-import-paths": "^1.6.1",
-    "eslint-plugin-perfectionist": "^4.10.1",
-    "jiti": "^2.4.2",
-    "knip": "^5.46.4",
-    "sentencer": "^0.2.1",
-    "typescript": "^5.8.2",
-    "typescript-eslint": "^8.29.0",
-    "vitest": "^3.1.1"
-  },
+  "devDependencies": {},
   "exports": {
     ".": "./bin/main.js"
   },

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

@@ -1,26 +0,0 @@
-import type { LogObject } from "../../../../core-types.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 "../../../../core-types.js";
-export type { LogLevelDeprecated, LogTypeDeprecated, } from "../levels/levels.js";

package/bin/libs/core/core-main.d.ts

@@ -1,23 +0,0 @@
-export type { LogLevelDeprecated, LogTypeDeprecated, } from "./core-impl/deprecated/components/levels/levels.js";
-export { LogLevelsDeprecated, LogTypesDeprecated, } from "./core-impl/deprecated/components/levels/levels.js";
-export { createRelinkaBaseDeprecated, relinkaBasicDeprecated, } from "./core-impl/deprecated/components/modes/basic.js";
-export { createRelinkaBrowserDeprecatedDeprecated, relinkaBrowserDeprecated, } from "./core-impl/deprecated/components/modes/browser.js";
-export { relinkaDeprecated } from "./core-impl/deprecated/components/relinka-deprecated/logger.js";
-export { createRelinkaSharedDeprecated, relinkaInstanceDeprecated, } from "./core-impl/deprecated/components/relinka-deprecated/mod.js";
-export type { LogFn, RelinkaInstanceDeprecated, } from "./core-impl/deprecated/components/relinka-deprecated/relinka.js";
-export { RelinkaInterface, createRelinkaDeprecated, } from "./core-impl/deprecated/components/relinka-deprecated/relinka.js";
-export { BasicReporter } from "./core-impl/deprecated/components/reporters/basic.js";
-export { BrowserReporter } from "./core-impl/deprecated/components/reporters/browser.js";
-export { TYPE_COLOR_MAP, LEVEL_COLOR_MAP, FancyReporter, } from "./core-impl/deprecated/components/reporters/fancy.js";
-export type { RelinkaOptions, FormatOptions, InputLogObject, LogObject, RelinkaReporter, } from "./core-types.js";
-export type { BoxBorderStyle, BoxStyle, BoxOpts, } from "./core-impl/deprecated/utils/box.js";
-export { box } from "./core-impl/deprecated/utils/box.js";
-export type { ColorName, ColorFunction, } from "./core-impl/deprecated/utils/deprecatedColors.js";
-export { colors, getColor, colorize, } from "./core-impl/deprecated/utils/deprecatedColors.js";
-export { parseStack } from "./core-impl/deprecated/utils/error.js";
-export { compileFormat, formatString, } from "./core-impl/deprecated/utils/format.js";
-export { isPlainObject, isLogObj } from "./core-impl/deprecated/utils/log.js";
-export { writeStream } from "./core-impl/deprecated/utils/stream.js";
-export { stripAnsi, centerAlign, rightAlign, leftAlign, align, } from "./core-impl/deprecated/utils/string.js";
-export type { TreeItemObject, TreeItem, TreeOptions, } from "./core-impl/deprecated/utils/tree.js";
-export { formatTree } from "./core-impl/deprecated/utils/tree.js";

package/bin/libs/core/core-main.js

@@ -1,49 +0,0 @@
-export {
-  LogLevelsDeprecated,
-  LogTypesDeprecated
-} from "./core-impl/deprecated/components/levels/levels.js";
-export {
-  createRelinkaBaseDeprecated,
-  relinkaBasicDeprecated
-} from "./core-impl/deprecated/components/modes/basic.js";
-export {
-  createRelinkaBrowserDeprecatedDeprecated,
-  relinkaBrowserDeprecated
-} from "./core-impl/deprecated/components/modes/browser.js";
-export { relinkaDeprecated } from "./core-impl/deprecated/components/relinka-deprecated/logger.js";
-export {
-  createRelinkaSharedDeprecated,
-  relinkaInstanceDeprecated
-} from "./core-impl/deprecated/components/relinka-deprecated/mod.js";
-export {
-  RelinkaInterface,
-  createRelinkaDeprecated
-} from "./core-impl/deprecated/components/relinka-deprecated/relinka.js";
-export { BasicReporter } from "./core-impl/deprecated/components/reporters/basic.js";
-export { BrowserReporter } from "./core-impl/deprecated/components/reporters/browser.js";
-export {
-  TYPE_COLOR_MAP,
-  LEVEL_COLOR_MAP,
-  FancyReporter
-} from "./core-impl/deprecated/components/reporters/fancy.js";
-export { box } from "./core-impl/deprecated/utils/box.js";
-export {
-  colors,
-  getColor,
-  colorize
-} from "./core-impl/deprecated/utils/deprecatedColors.js";
-export { parseStack } from "./core-impl/deprecated/utils/error.js";
-export {
-  compileFormat,
-  formatString
-} from "./core-impl/deprecated/utils/format.js";
-export { isPlainObject, isLogObj } from "./core-impl/deprecated/utils/log.js";
-export { writeStream } from "./core-impl/deprecated/utils/stream.js";
-export {
-  stripAnsi,
-  centerAlign,
-  rightAlign,
-  leftAlign,
-  align
-} from "./core-impl/deprecated/utils/string.js";
-export { formatTree } from "./core-impl/deprecated/utils/tree.js";

package/bin/libs/core/core-types.d.ts

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

package/bin/libs/core/core-types.js

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