@reliverse/relinka 1.3.1 → 1.3.3

package/{dist-npm → bin/deprecated}/components/relinka/relinka.d.ts

@@ -1,140 +1,141 @@
-import type { LogType } from "../../components/levels/levels.js";
-import type { RelinkaReporter, InputLogObject, LogObject, RelinkaOptions } from "../../types/mod.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.
- *
- * @class Relinka
- */
-export declare class RelinkaInterface {
-    options: RelinkaOptions;
-    _lastLog: {
-        serialized?: string;
-        object?: LogObject;
-        count?: number;
-        time?: Date;
-        timeout?: ReturnType<typeof setTimeout>;
-    };
-    _paused: boolean;
-    _queue: any[];
-    _mockFn?: RelinkaOptions["mockFn"];
-    /**
-     * Creates an instance of Relinka with specified options or defaults.
-     *
-     * @param {Partial<RelinkaOptions>} [options={}] - Configuration options for the Relinka instance.
-     */
-    constructor(options?: Partial<RelinkaOptions>);
-    /**
-     * Gets the current log level of the Relinka instance.
-     *
-     * @returns {number} The current log level.
-     */
-    get level(): any;
-    /**
-     * Sets the minimum log level that will be output by the instance.
-     *
-     * @param {number} level - The new log level to set.
-     */
-    set level(level: any);
-    /**
-     * 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}.
-     * @returns {RelinkaInstance} A new Relinka instance. See {@link RelinkaInstance}.
-     */
-    create(options: Partial<RelinkaOptions>): RelinkaInstance;
-    /**
-     * Creates a new Relinka instance with the specified default log object properties.
-     *
-     * @param {InputLogObject} defaults - Default properties to include in any log from the new instance. See {@link InputLogObject}.
-     * @returns {RelinkaInstance} A new Relinka instance. See {@link RelinkaInstance}.
-     */
-    withDefaults(defaults: InputLogObject): RelinkaInstance;
-    /**
-     * Creates a new Relinka instance with a specified tag, which will be included in every log.
-     *
-     * @param {string} tag - The tag to include in each log of the new instance.
-     * @returns {RelinkaInstance} A new Relinka instance. See {@link RelinkaInstance}.
-     */
-    withTag(tag: string): RelinkaInstance;
-    /**
-     * 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}.
-     * @returns {Relinka} The current Relinka instance.
-     */
-    addReporter(reporter: RelinkaReporter): 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}.
-     * @returns {Relinka} The current Relinka instance.
-     */
-    removeReporter(reporter: RelinkaReporter): 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}.
-     * @returns {Relinka} The current Relinka instance.
-     */
-    setReporters(reporters: RelinkaReporter[]): this;
-    wrapAll(): void;
-    restoreAll(): void;
-    /**
-     * Overrides console methods with Relinka logging methods for consistent logging.
-     */
-    wrapConsole(): void;
-    /**
-     * Restores the original console methods, removing Relinka overrides.
-     */
-    restoreConsole(): void;
-    /**
-     * Overrides standard output and error streams to redirect them through RelinkaInterface.
-     */
-    wrapStd(): void;
-    _wrapStream(stream: NodeJS.WriteStream | undefined, type: LogType): void;
-    /**
-     * Restores the original standard output and error streams, removing the Relinka redirection.
-     */
-    restoreStd(): void;
-    _restoreStream(stream?: NodeJS.WriteStream): void;
-    /**
-     * Clears the internal state of the Relinka instance.
-     * This will reset any throttling, last log data, clear any queued logs,
-     * and optionally clear the actual console.
-     *
-     * @param {boolean} clearConsole - Whether to clear the actual console. Defaults to false.
-     */
-    clear(clearConsole?: boolean): void;
-    /**
-     * Pauses logging, queues incoming logs until resumed.
-     */
-    pauseLogs(): void;
-    /**
-     * Resumes logging, processing any queued logs.
-     */
-    resumeLogs(): void;
-    /**
-     * 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"]}.
-     */
-    mockTypes(mockFn?: RelinkaOptions["mockFn"]): void;
-    _wrapLogFn(defaults: InputLogObject, isRaw?: boolean): (...args: any[]) => boolean;
-    _logFn(defaults: InputLogObject, args: any[], isRaw?: boolean): boolean;
-    _log(logObj: LogObject): void;
-}
-export type LogFn = {
-    (message: InputLogObject | any, ...args: any[]): void;
-    raw: (...args: any[]) => void;
-};
-export type RelinkaInstance = RelinkaInterface & Record<LogType, LogFn>;
-/**
- * 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}.
- * @returns {RelinkaInstance} A new instance of RelinkaInterface. See {@link RelinkaInstance}.
- */
-export declare function createRelinka(options?: Partial<RelinkaOptions>): RelinkaInstance;
+/// <reference types="node" />
+import type { InputLogObject, LogObject, RelinkaOptions, RelinkaReporter } from "../../types/mod.js";
+import { type LogType } from "../levels/levels.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.
+ *
+ * @class Relinka
+ */
+export declare class RelinkaInterface {
+    options: RelinkaOptions;
+    _lastLog: {
+        serialized?: string;
+        object?: LogObject;
+        count?: number;
+        time?: Date;
+        timeout?: ReturnType<typeof setTimeout>;
+    };
+    _paused: boolean;
+    _queue: any[];
+    _mockFn?: RelinkaOptions["mockFn"];
+    /**
+     * Creates an instance of Relinka with specified options or defaults.
+     *
+     * @param {Partial<RelinkaOptions>} [options={}] - Configuration options for the Relinka instance.
+     */
+    constructor(options?: Partial<RelinkaOptions>);
+    /**
+     * Gets the current log level of the Relinka instance.
+     *
+     * @returns {number} The current log level.
+     */
+    get level(): any;
+    /**
+     * Sets the minimum log level that will be output by the instance.
+     *
+     * @param {number} level - The new log level to set.
+     */
+    set level(level: any);
+    /**
+     * 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}.
+     * @returns {RelinkaInstance} A new Relinka instance. See {@link RelinkaInstance}.
+     */
+    create(options: Partial<RelinkaOptions>): RelinkaInstance;
+    /**
+     * Creates a new Relinka instance with the specified default log object properties.
+     *
+     * @param {InputLogObject} defaults - Default properties to include in any log from the new instance. See {@link InputLogObject}.
+     * @returns {RelinkaInstance} A new Relinka instance. See {@link RelinkaInstance}.
+     */
+    withDefaults(defaults: InputLogObject): RelinkaInstance;
+    /**
+     * Creates a new Relinka instance with a specified tag, which will be included in every log.
+     *
+     * @param {string} tag - The tag to include in each log of the new instance.
+     * @returns {RelinkaInstance} A new Relinka instance. See {@link RelinkaInstance}.
+     */
+    withTag(tag: string): RelinkaInstance;
+    /**
+     * 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}.
+     * @returns {Relinka} The current Relinka instance.
+     */
+    addReporter(reporter: RelinkaReporter): 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}.
+     * @returns {Relinka} The current Relinka instance.
+     */
+    removeReporter(reporter: RelinkaReporter): 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}.
+     * @returns {Relinka} The current Relinka instance.
+     */
+    setReporters(reporters: RelinkaReporter[]): this;
+    wrapAll(): void;
+    restoreAll(): void;
+    /**
+     * Overrides console methods with Relinka logging methods for consistent logging.
+     */
+    wrapConsole(): void;
+    /**
+     * Restores the original console methods, removing Relinka overrides.
+     */
+    restoreConsole(): void;
+    /**
+     * Overrides standard output and error streams to redirect them through RelinkaInterface.
+     */
+    wrapStd(): void;
+    _wrapStream(stream: NodeJS.WriteStream | undefined, type: LogType): void;
+    /**
+     * Restores the original standard output and error streams, removing the Relinka redirection.
+     */
+    restoreStd(): void;
+    _restoreStream(stream?: NodeJS.WriteStream): void;
+    /**
+     * Clears the internal state of the Relinka instance.
+     * This will reset any throttling, last log data, clear any queued logs,
+     * and optionally clear the actual console.
+     *
+     * @param {boolean} clearConsole - Whether to clear the actual console. Defaults to false.
+     */
+    clear(clearConsole?: boolean): void;
+    /**
+     * Pauses logging, queues incoming logs until resumed.
+     */
+    pauseLogs(): void;
+    /**
+     * Resumes logging, processing any queued logs.
+     */
+    resumeLogs(): void;
+    /**
+     * 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"]}.
+     */
+    mockTypes(mockFn?: RelinkaOptions["mockFn"]): void;
+    _wrapLogFn(defaults: InputLogObject, isRaw?: boolean): (...args: any[]) => boolean;
+    _logFn(defaults: InputLogObject, args: any[], isRaw?: boolean): boolean;
+    _log(logObj: LogObject): void;
+}
+export type LogFn = {
+    (message: InputLogObject | any, ...args: any[]): void;
+    raw: (...args: any[]) => void;
+};
+export type RelinkaInstance = RelinkaInterface & Record<LogType, LogFn>;
+/**
+ * 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}.
+ * @returns {RelinkaInstance} A new instance of RelinkaInterface. See {@link RelinkaInstance}.
+ */
+export declare function createRelinka(options?: Partial<RelinkaOptions>): RelinkaInstance;

package/{dist-npm → bin/deprecated}/components/relinka/relinka.js

@@ -1,5 +1,7 @@
 import { defu } from "defu";
-import { LogTypes } from "../../components/levels/levels.js";
+import {
+  LogTypes
+} from "../levels/levels.js";
 import { isLogObj } from "../../utils/log.js";
 export class RelinkaInterface {
   options;
@@ -111,7 +113,7 @@ export class RelinkaInterface {
    */
   withTag(tag) {
     return this.withDefaults({
-      tag: this.options.defaults.tag ? this.options.defaults.tag + ":" + tag : tag
+      tag: this.options.defaults.tag ? `${this.options.defaults.tag}:${tag}` : tag
     });
   }
   /**
@@ -166,8 +168,8 @@ export class RelinkaInterface {
    */
   wrapConsole() {
     for (const type in this.options.types) {
-      if (!console["__" + type]) {
-        console["__" + type] = console[type];
+      if (!console[`__${type}`]) {
+        console[`__${type}`] = console[type];
       }
       console[type] = this[type].raw;
     }
@@ -177,9 +179,9 @@ export class RelinkaInterface {
    */
   restoreConsole() {
     for (const type in this.options.types) {
-      if (console["__" + type]) {
-        console[type] = console["__" + type];
-        delete console["__" + type];
+      if (console[`__${type}`]) {
+        console[type] = console[`__${type}`];
+        delete console[`__${type}`];
       }
     }
   }
@@ -214,7 +216,7 @@ export class RelinkaInterface {
     }
     if (stream.__write) {
       stream.write = stream.__write;
-      delete stream.__write;
+      stream.__write = void 0;
     }
   }
   /**
@@ -291,14 +293,15 @@ export class RelinkaInterface {
     }
     if (logObj.message) {
       logObj.args.unshift(logObj.message);
-      delete logObj.message;
+      logObj.message = void 0;
     }
     if (logObj.additional) {
       if (!Array.isArray(logObj.additional)) {
         logObj.additional = logObj.additional.split("\n");
       }
-      logObj.args.push("\n" + logObj.additional.join("\n"));
-      delete logObj.additional;
+      logObj.args.push(`
+${logObj.additional.join("\n")}`);
+      logObj.additional = void 0;
     }
     logObj.type = typeof logObj.type === "string" ? logObj.type.toLowerCase() : "log";
     logObj.tag = typeof logObj.tag === "string" ? logObj.tag : "";

package/{dist-npm → bin/deprecated}/components/reporters/basic.d.ts

@@ -1,11 +1,11 @@
-import type { LogObject, RelinkaReporter, FormatOptions, RelinkaOptions } from "../../types/mod.js";
-export declare class BasicReporter implements RelinkaReporter {
-    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;
-    }): any;
-}
+import type { LogObject, RelinkaReporter, FormatOptions, RelinkaOptions } from "../../types/mod.js";
+export declare class BasicReporter implements RelinkaReporter {
+    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;
+    }): any;
+}

package/{dist-npm → bin/deprecated}/components/reporters/basic.js

@@ -4,12 +4,13 @@ import { writeStream } from "../../utils/stream.js";
 const bracket = (x) => x ? `[${x}]` : "";
 export class BasicReporter {
   formatStack(stack) {
-    return "  " + parseStack(stack).join("\n  ");
+    return `  ${parseStack(stack).join("\n  ")}`;
   }
   formatArgs(args, opts) {
     const formattedArgs = args.map((arg) => {
       if (arg && typeof arg.stack === "string") {
-        return arg.message + "\n" + this.formatStack(arg.stack);
+        return `${arg.message}
+${this.formatStack(arg.stack)}`;
       }
       return arg;
     });
@@ -24,11 +25,13 @@ export class BasicReporter {
   formatLogObj(logObj, opts) {
     const message = this.formatArgs(logObj.args, opts);
     if (logObj.type === "box") {
-      return "\n" + [
+      return `
+${[
         bracket(logObj.tag),
-        logObj["title"] && logObj["title"],
+        logObj.title && logObj.title,
         ...message.split("\n")
-      ].filter(Boolean).map((l) => " > " + l).join("\n") + "\n";
+      ].filter(Boolean).map((l) => ` > ${l}`).join("\n")}
+`;
     }
     return this.filterAndJoin([
       bracket(logObj.type),
@@ -42,7 +45,8 @@ export class BasicReporter {
       ...ctx.options.formatOptions
     });
     return writeStream(
-      line + "\n",
+      `${line}
+`,
       logObj.level < 2 ? ctx.options.stderr || process.stderr : ctx.options.stdout || process.stdout
     );
   }

package/{dist-npm → bin/deprecated}/components/reporters/browser.d.ts

@@ -1,10 +1,10 @@
-import type { LogObject } from "../../types/mod.js";
-export declare class BrowserReporter {
-    options: any;
-    defaultColor: string;
-    levelColorMap: Record<number, string>;
-    typeColorMap: Record<string, string>;
-    constructor(options: any);
-    _getLogFn(level: number): any;
-    log(logObj: LogObject): void;
-}
+import type { LogObject } from "../../../main.js";
+export declare class BrowserReporter {
+    options: any;
+    defaultColor: string;
+    levelColorMap: Record<number, string>;
+    typeColorMap: Record<string, string>;
+    constructor(options: any);
+    _getLogFn(level: number): any;
+    log(logObj: LogObject): void;
+}

package/{dist-npm → bin/deprecated}/components/reporters/fancy.d.ts

@@ -1,10 +1,10 @@
-import type { LogLevel, LogType } from "../../components/levels/levels.js";
-import type { FormatOptions, LogObject } from "../../types/mod.js";
-import { BasicReporter } from "../../components/reporters/basic.js";
-export declare const TYPE_COLOR_MAP: Partial<Record<LogType, string>>;
-export declare const LEVEL_COLOR_MAP: Partial<Record<LogLevel, string>>;
-export declare class FancyReporter extends BasicReporter {
-    formatStack(stack: string): string;
-    formatType(logObj: LogObject, isBadge: boolean): any;
-    formatLogObj(logObj: LogObject, opts: FormatOptions): any;
-}
+import type { LogLevel, LogType } from "../levels/levels.js";
+import type { FormatOptions, LogObject } from "../../../main.js";
+import { BasicReporter } from "./basic.js";
+export declare const TYPE_COLOR_MAP: Partial<Record<LogType, string>>;
+export declare const LEVEL_COLOR_MAP: Partial<Record<LogLevel, string>>;
+export declare class FancyReporter extends BasicReporter {
+    formatStack(stack: string): string;
+    formatType(logObj: LogObject, isBadge: boolean): any;
+    formatLogObj(logObj: LogObject, opts: FormatOptions): any;
+}

package/{dist-npm → bin/deprecated}/components/reporters/fancy.js

@@ -1,6 +1,6 @@
 import { isUnicodeSupported } from "@reliverse/runtime";
 import stringWidth from "string-width";
-import { BasicReporter } from "../../components/reporters/basic.js";
+import { BasicReporter } from "./basic.js";
 import { box } from "../../utils/box.js";
 import { colors } from "../../utils/deprecatedColors.js";
 import { parseStack } from "../../utils/error.js";
@@ -39,9 +39,10 @@ function getStringWidth(str) {
 }
 export class FancyReporter extends BasicReporter {
   formatStack(stack) {
-    return "\n" + parseStack(stack).map(
-      (line) => "  " + line.replace(/^at +/, (m) => colors.gray(m)).replace(/\((.+)\)/, (_, m) => `(${colors.cyan(m)})`)
-    ).join("\n");
+    return `
+${parseStack(stack).map(
+      (line) => `  ${line.replace(/^at +/, (m) => colors.gray(m)).replace(/\((.+)\)/, (_, m) => `(${colors.cyan(m)})`)}`
+    ).join("\n")}`;
   }
   formatType(logObj, isBadge) {
     const typeColor = TYPE_COLOR_MAP[logObj.type] || LEVEL_COLOR_MAP[logObj.level] || "gray";
@@ -60,17 +61,18 @@ export class FancyReporter extends BasicReporter {
     if (logObj.type === "box") {
       return box(
         characterFormat(
-          message + (additional.length > 0 ? "\n" + additional.join("\n") : "")
+          message + (additional.length > 0 ? `
+${additional.join("\n")}` : "")
         ),
         {
-          title: logObj["title"] ? characterFormat(logObj["title"]) : void 0,
-          style: logObj["style"]
+          title: logObj.title ? characterFormat(logObj.title) : void 0,
+          style: logObj.style
         }
       );
     }
     const date = this.formatDate(logObj.date, opts);
     const coloredDate = date && colors.gray(date);
-    const isBadge = logObj["badge"] ?? logObj.level < 2;
+    const isBadge = logObj.badge ?? logObj.level < 2;
     const type = this.formatType(logObj, isBadge);
     const tag = logObj.tag ? colors.gray(logObj.tag) : "";
     let line;
@@ -79,13 +81,16 @@ export class FancyReporter extends BasicReporter {
     const space = (opts.columns || 0) - getStringWidth(left) - getStringWidth(right) - 2;
     line = space > 0 && (opts.columns || 0) >= 80 ? left + " ".repeat(space) + right : (right ? `${colors.gray(`[${right}]`)} ` : "") + left;
     line += characterFormat(
-      additional.length > 0 ? "\n" + additional.join("\n") : ""
+      additional.length > 0 ? `
+${additional.join("\n")}` : ""
     );
     if (logObj.type === "trace") {
-      const _err = new Error("Trace: " + logObj.message);
+      const _err = new Error(`Trace: ${logObj.message}`);
       line += this.formatStack(_err.stack || "");
     }
-    return isBadge ? "\n" + line + "\n" : line;
+    return isBadge ? `
+${line}
+` : line;
   }
 }
 function characterFormat(str) {

package/{dist-npm/main.d.ts → bin/deprecated/depd-main.d.ts}

@@ -1,3 +1,2 @@
-export * from "./components/relinka/mod.js";
-export * from "./components/messages/mod.js";
-export * from "./components/relinka/logger.js";
+export * from "./components/relinka/mod.js";
+export * from "./components/relinka/logger.js";

package/{dist-npm/main.js → bin/deprecated/depd-main.js}

@@ -1,3 +1,2 @@
 export * from "./components/relinka/mod.js";
-export * from "./components/messages/mod.js";
 export * from "./components/relinka/logger.js";