@vvlad1973/simple-logger 2.1.7 → 2.1.8

package/dist/constants/constants.d.ts

@@ -1,9 +1,9 @@
-export declare const LoggerLevels: {
-    readonly TRACE: "trace";
-    readonly DEBUG: "debug";
-    readonly INFO: "info";
-    readonly WARN: "warn";
-    readonly ERROR: "error";
-    readonly FATAL: "fatal";
-    readonly SILENT: "silent";
-};
+export declare const LoggerLevels: {
+    readonly TRACE: "trace";
+    readonly DEBUG: "debug";
+    readonly INFO: "info";
+    readonly WARN: "warn";
+    readonly ERROR: "error";
+    readonly FATAL: "fatal";
+    readonly SILENT: "silent";
+};

package/dist/constants/constants.js

@@ -1,10 +1,10 @@
-export const LoggerLevels = {
-    TRACE: 'trace',
-    DEBUG: 'debug',
-    INFO: 'info',
-    WARN: 'warn',
-    ERROR: 'error',
-    FATAL: 'fatal',
-    SILENT: 'silent',
-};
+export const LoggerLevels = {
+    TRACE: 'trace',
+    DEBUG: 'debug',
+    INFO: 'info',
+    WARN: 'warn',
+    ERROR: 'error',
+    FATAL: 'fatal',
+    SILENT: 'silent',
+};
 //# sourceMappingURL=constants.js.map

package/dist/helpers/helpers.d.ts

@@ -1,31 +1,31 @@
-import { LoggerLevel, PreparedLogCall } from '../types/simple-logger.types.js';
-/**
- * Extracts the message and rest of the arguments from the provided array.
- *
- * If the first argument is an object and the second argument is a string, the second argument is considered the message.
- * If the first argument is a string, it is considered the message.
- * Otherwise, an empty message is returned.
- *
- * @param {unknown[]} args - The array of arguments to extract the message from.
- * @return {{ msg: string; rest: unknown[] }} An object containing the extracted message and the rest of the arguments.
- */
-export declare function extractMessage(args: unknown[]): {
-    msg: string;
-    rest: unknown[];
-};
-/**
- * Extracts the context object from the provided array of arguments.
- *
- * @param {unknown[]} args - The array of arguments to extract the context from.
- * @return {Record<string, unknown>} The extracted context object, or an empty object if no context is found.
- */
-export declare function extractContext(args: unknown[]): Record<string, unknown>;
-/**
- * Returns a string with the provided label colored according to the specified logging level.
- *
- * @param {LoggerLevel} level - The logging level to determine the color from.
- * @param {string} label - The label to be colored.
- * @return {string} The colored label.
- */
-export declare function colorizeLevel(level: LoggerLevel, label: string): string;
-export declare function prepareLogCall(args: unknown[]): PreparedLogCall;
+import { LoggerLevel, PreparedLogCall } from '../types/simple-logger.types.js';
+/**
+ * Extracts the message and rest of the arguments from the provided array.
+ *
+ * If the first argument is an object and the second argument is a string, the second argument is considered the message.
+ * If the first argument is a string, it is considered the message.
+ * Otherwise, an empty message is returned.
+ *
+ * @param {unknown[]} args - The array of arguments to extract the message from.
+ * @return {{ msg: string; rest: unknown[] }} An object containing the extracted message and the rest of the arguments.
+ */
+export declare function extractMessage(args: unknown[]): {
+    msg: string;
+    rest: unknown[];
+};
+/**
+ * Extracts the context object from the provided array of arguments.
+ *
+ * @param {unknown[]} args - The array of arguments to extract the context from.
+ * @return {Record<string, unknown>} The extracted context object, or an empty object if no context is found.
+ */
+export declare function extractContext(args: unknown[]): Record<string, unknown>;
+/**
+ * Returns a string with the provided label colored according to the specified logging level.
+ *
+ * @param {LoggerLevel} level - The logging level to determine the color from.
+ * @param {string} label - The label to be colored.
+ * @return {string} The colored label.
+ */
+export declare function colorizeLevel(level: LoggerLevel, label: string): string;
+export declare function prepareLogCall(args: unknown[]): PreparedLogCall;

package/dist/helpers/helpers.js

@@ -1,81 +1,81 @@
-import chalk from 'chalk';
-import { LoggerLevels } from '../constants/constants.js';
-/**
- * Extracts the message and rest of the arguments from the provided array.
- *
- * If the first argument is an object and the second argument is a string, the second argument is considered the message.
- * If the first argument is a string, it is considered the message.
- * Otherwise, an empty message is returned.
- *
- * @param {unknown[]} args - The array of arguments to extract the message from.
- * @return {{ msg: string; rest: unknown[] }} An object containing the extracted message and the rest of the arguments.
- */
-export function extractMessage(args) {
-    const [first, second, ...rest] = args;
-    if (typeof first === 'object' &&
-        first !== null &&
-        typeof second === 'string') {
-        return { msg: second, rest };
-    }
-    if (typeof first === 'string') {
-        return {
-            msg: first,
-            rest: [second, ...rest].filter((value) => value !== undefined),
-        };
-    }
-    return { msg: '', rest: [] };
-}
-/**
- * Extracts the context object from the provided array of arguments.
- *
- * @param {unknown[]} args - The array of arguments to extract the context from.
- * @return {Record<string, unknown>} The extracted context object, or an empty object if no context is found.
- */
-export function extractContext(args) {
-    const [first] = args;
-    if (typeof first === 'object' && first !== null && !Array.isArray(first)) {
-        return first;
-    }
-    return {};
-}
-/**
- * Returns a string with the provided label colored according to the specified logging level.
- *
- * @param {LoggerLevel} level - The logging level to determine the color from.
- * @param {string} label - The label to be colored.
- * @return {string} The colored label.
- */
-export function colorizeLevel(level, label) {
-    switch (level) {
-        case LoggerLevels.DEBUG:
-        case LoggerLevels.TRACE:
-            return chalk.gray(label);
-        case LoggerLevels.INFO:
-            return chalk.green(label);
-        case LoggerLevels.WARN:
-            return chalk.yellow(label);
-        case LoggerLevels.ERROR:
-        case LoggerLevels.FATAL:
-            return chalk.red(label);
-        default:
-            return label;
-    }
-    /**
-     * Prepares the log call by rearranging the provided arguments into a standardized format.
-     *
-     * @param {unknown[]} args - The array of arguments to prepare for the log call.
-     * @return {PreparedLogCall} The prepared log call arguments, or null if the input is invalid.
-     */
-}
-export function prepareLogCall(args) {
-    if (typeof args[0] === 'string') {
-        return [args[0], ...args.slice(1)];
-    }
-    if (typeof args[0] === 'object' && args[0] !== null) {
-        const msg = typeof args[1] === 'string' ? args[1] : undefined;
-        const rest = args.slice(msg ? 2 : 1);
-        return [args[0], msg, ...rest];
-    }
-    return null;
-}
+import chalk from 'chalk';
+import { LoggerLevels } from '../constants/constants.js';
+/**
+ * Extracts the message and rest of the arguments from the provided array.
+ *
+ * If the first argument is an object and the second argument is a string, the second argument is considered the message.
+ * If the first argument is a string, it is considered the message.
+ * Otherwise, an empty message is returned.
+ *
+ * @param {unknown[]} args - The array of arguments to extract the message from.
+ * @return {{ msg: string; rest: unknown[] }} An object containing the extracted message and the rest of the arguments.
+ */
+export function extractMessage(args) {
+    const [first, second, ...rest] = args;
+    if (typeof first === 'object' &&
+        first !== null &&
+        typeof second === 'string') {
+        return { msg: second, rest };
+    }
+    if (typeof first === 'string') {
+        return {
+            msg: first,
+            rest: [second, ...rest].filter((value) => value !== undefined),
+        };
+    }
+    return { msg: '', rest: [] };
+}
+/**
+ * Extracts the context object from the provided array of arguments.
+ *
+ * @param {unknown[]} args - The array of arguments to extract the context from.
+ * @return {Record<string, unknown>} The extracted context object, or an empty object if no context is found.
+ */
+export function extractContext(args) {
+    const [first] = args;
+    if (typeof first === 'object' && first !== null && !Array.isArray(first)) {
+        return first;
+    }
+    return {};
+}
+/**
+ * Returns a string with the provided label colored according to the specified logging level.
+ *
+ * @param {LoggerLevel} level - The logging level to determine the color from.
+ * @param {string} label - The label to be colored.
+ * @return {string} The colored label.
+ */
+export function colorizeLevel(level, label) {
+    switch (level) {
+        case LoggerLevels.DEBUG:
+        case LoggerLevels.TRACE:
+            return chalk.gray(label);
+        case LoggerLevels.INFO:
+            return chalk.green(label);
+        case LoggerLevels.WARN:
+            return chalk.yellow(label);
+        case LoggerLevels.ERROR:
+        case LoggerLevels.FATAL:
+            return chalk.red(label);
+        default:
+            return label;
+    }
+    /**
+     * Prepares the log call by rearranging the provided arguments into a standardized format.
+     *
+     * @param {unknown[]} args - The array of arguments to prepare for the log call.
+     * @return {PreparedLogCall} The prepared log call arguments, or null if the input is invalid.
+     */
+}
+export function prepareLogCall(args) {
+    if (typeof args[0] === 'string') {
+        return [args[0], ...args.slice(1)];
+    }
+    if (typeof args[0] === 'object' && args[0] !== null) {
+        const msg = typeof args[1] === 'string' ? args[1] : undefined;
+        const rest = args.slice(msg ? 2 : 1);
+        return [args[0], msg, ...rest];
+    }
+    return null;
+}
 //# sourceMappingURL=helpers.js.map

package/dist/helpers/validators.d.ts

@@ -1,17 +1,17 @@
-import { ExternalLogger } from '../types/simple-logger.types.js';
-/**
- * Checks if the provided logger is a valid ExternalLogger instance.
- *
- * @param {unknown} logger - The logger to validate.
- * @return {logger is ExternalLogger} True if the logger is a valid ExternalLogger, false otherwise.
- */
-export declare function isValidLogger(logger: unknown): logger is ExternalLogger;
-/**
- * Checks if the provided logger is an ExternalLogger instance with a child method.
- *
- * @param {unknown} logger - The logger to check.
- * @return {logger is ExternalLogger & { child: Function }} True if the logger is an ExternalLogger with a child method, false otherwise.
- */
-export declare function hasChild(logger: unknown): logger is ExternalLogger & {
-    child: Function;
-};
+import { ExternalLogger } from '../types/simple-logger.types.js';
+/**
+ * Checks if the provided logger is a valid ExternalLogger instance.
+ *
+ * @param {unknown} logger - The logger to validate.
+ * @return {logger is ExternalLogger} True if the logger is a valid ExternalLogger, false otherwise.
+ */
+export declare function isValidLogger(logger: unknown): logger is ExternalLogger;
+/**
+ * Checks if the provided logger is an ExternalLogger instance with a child method.
+ *
+ * @param {unknown} logger - The logger to check.
+ * @return {logger is ExternalLogger & { child: Function }} True if the logger is an ExternalLogger with a child method, false otherwise.
+ */
+export declare function hasChild(logger: unknown): logger is ExternalLogger & {
+    child: Function;
+};

package/dist/helpers/validators.js

@@ -1,27 +1,27 @@
-import { LoggerLevels } from '../constants/constants.js';
-/**
- * Checks if the provided logger is a valid ExternalLogger instance.
- *
- * @param {unknown} logger - The logger to validate.
- * @return {logger is ExternalLogger} True if the logger is a valid ExternalLogger, false otherwise.
- */
-export function isValidLogger(logger) {
-    const levels = Object.values(LoggerLevels);
-    if (typeof logger !== 'object' || logger === null) {
-        return false;
-    }
-    const candidate = logger;
-    return levels.some((level) => typeof candidate[level] === 'function');
-}
-/**
- * Checks if the provided logger is an ExternalLogger instance with a child method.
- *
- * @param {unknown} logger - The logger to check.
- * @return {logger is ExternalLogger & { child: Function }} True if the logger is an ExternalLogger with a child method, false otherwise.
- */
-export function hasChild(logger) {
-    return (typeof logger === 'object' &&
-        logger !== null &&
-        typeof logger.child === 'function');
-}
+import { LoggerLevels } from '../constants/constants.js';
+/**
+ * Checks if the provided logger is a valid ExternalLogger instance.
+ *
+ * @param {unknown} logger - The logger to validate.
+ * @return {logger is ExternalLogger} True if the logger is a valid ExternalLogger, false otherwise.
+ */
+export function isValidLogger(logger) {
+    const levels = Object.values(LoggerLevels);
+    if (typeof logger !== 'object' || logger === null) {
+        return false;
+    }
+    const candidate = logger;
+    return levels.some((level) => typeof candidate[level] === 'function');
+}
+/**
+ * Checks if the provided logger is an ExternalLogger instance with a child method.
+ *
+ * @param {unknown} logger - The logger to check.
+ * @return {logger is ExternalLogger & { child: Function }} True if the logger is an ExternalLogger with a child method, false otherwise.
+ */
+export function hasChild(logger) {
+    return (typeof logger === 'object' &&
+        logger !== null &&
+        typeof logger.child === 'function');
+}
 //# sourceMappingURL=validators.js.map

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import SimpleLogger from './classes/simple-logger.js';
-export default SimpleLogger;
-export { SimpleLogger };
-export * from './types/simple-logger.types.js';
-export * from './constants/constants.js';
+import SimpleLogger from './classes/simple-logger.js';
+export default SimpleLogger;
+export { SimpleLogger };
+export * from './types/simple-logger.types.js';
+export * from './constants/constants.js';

package/dist/index.js

@@ -1,6 +1,6 @@
-import SimpleLogger from './classes/simple-logger.js';
-export default SimpleLogger;
-export { SimpleLogger };
-export * from './types/simple-logger.types.js';
-export * from './constants/constants.js';
+import SimpleLogger from './classes/simple-logger.js';
+export default SimpleLogger;
+export { SimpleLogger };
+export * from './types/simple-logger.types.js';
+export * from './constants/constants.js';
 //# sourceMappingURL=index.js.map

package/dist/simple-logger.d.ts

@@ -1,80 +1,80 @@
-/**
- * A module for simple logging with various logging levels.
- * @module SimpleLogger
- */
-export type ExternalLogger = {
-    trace?: LogFn;
-    debug?: LogFn;
-    info?: LogFn;
-    warn?: LogFn;
-    error?: LogFn;
-    fatal?: LogFn;
-    silent?: LogFn;
-    level?: string;
-};
-interface LogFn {
-    <T extends object>(obj: T, msg?: string, ...args: any[]): void;
-    (obj: unknown, msg?: string, ...args: any[]): void;
-    (msg: string, ...args: any[]): void;
-}
-declare const loggerLevels: readonly ["trace", "debug", "info", "warn", "error", "fatal", "silent"];
-export type LoggerLevel = (typeof loggerLevels)[number];
-/**
- * A simple logger class with various logging levels.
- * @class
- * @param {string} [level='info'] - Initial logging level.
- * @param {ExternalLogger | undefined | null} [externalLogger=null] - Optional external logger to use.
- */
-export declare class SimpleLogger {
-    #private;
-    isExternal: boolean;
-    constructor(level?: LoggerLevel, externalLogger?: ExternalLogger);
-    trace: LogFn;
-    debug: LogFn;
-    info: LogFn;
-    warn: LogFn;
-    error: LogFn;
-    fatal: LogFn;
-    silent: LogFn;
-    /**
-     * Updates the logging methods based on the current logging level.
-     * @private
-     */
-    private updateLoggingMethods;
-    /**
-     * Checks if the provided logger is valid.
-     * @private
-     * @param {any} logger - The logger to check.
-     * @returns {boolean} - True if the logger is valid, otherwise false.
-     */
-    private isValidLogger;
-    /**
-     * Gets the external logger method for a specific level.
-     * @param {string} method - The logger method to get.
-     * @param {string} [fallbackMethod] - The fallback logger method to get.
-     * @returns {LoggerMethod} - The logger method or a no-op function.
-     * @private
-     */
-    private getExternalLoggerMethod;
-    /**
-     * Sets the logging level.
-     * @param {string} level - The logging level to set.
-     */
-    setLevel(level: string): void;
-    /**
-     * Sets an external logger to be used.
-     * @param {ExternalLogger | undefined | null} logger - The external logger to set.
-     */
-    setExternalLogger(logger: ExternalLogger | undefined | null, level?: LoggerLevel): void;
-    /**
-     * Logs the start of a function.
-     * @param {string} [functionName] - Optional function name to log.
-     */
-    logFunctionStart(functionName?: string): void;
-    /**
-     * Logs the end of a function.
-     * @param {string} [functionName] - Optional function name to log.
-     */
-    logFunctionEnd(functionName?: string): void;
-}
-export default SimpleLogger;
+/**
+ * A module for simple logging with various logging levels.
+ * @module SimpleLogger
+ */
+export type ExternalLogger = {
+    trace?: LogFn;
+    debug?: LogFn;
+    info?: LogFn;
+    warn?: LogFn;
+    error?: LogFn;
+    fatal?: LogFn;
+    silent?: LogFn;
+    level?: string;
+};
+interface LogFn {
+    <T extends object>(obj: T, msg?: string, ...args: any[]): void;
+    (obj: unknown, msg?: string, ...args: any[]): void;
+    (msg: string, ...args: any[]): void;
+}
+declare const loggerLevels: readonly ["trace", "debug", "info", "warn", "error", "fatal", "silent"];
+export type LoggerLevel = (typeof loggerLevels)[number];
+/**
+ * A simple logger class with various logging levels.
+ * @class
+ * @param {string} [level='info'] - Initial logging level.
+ * @param {ExternalLogger | undefined | null} [externalLogger=null] - Optional external logger to use.
+ */
+export declare class SimpleLogger {
+    #private;
+    isExternal: boolean;
+    constructor(level?: LoggerLevel, externalLogger?: ExternalLogger);
+    trace: LogFn;
+    debug: LogFn;
+    info: LogFn;
+    warn: LogFn;
+    error: LogFn;
+    fatal: LogFn;
+    silent: LogFn;
+    /**
+     * Updates the logging methods based on the current logging level.
+     * @private
+     */
+    private updateLoggingMethods;
+    /**
+     * Checks if the provided logger is valid.
+     * @private
+     * @param {any} logger - The logger to check.
+     * @returns {boolean} - True if the logger is valid, otherwise false.
+     */
+    private isValidLogger;
+    /**
+     * Gets the external logger method for a specific level.
+     * @param {string} method - The logger method to get.
+     * @param {string} [fallbackMethod] - The fallback logger method to get.
+     * @returns {LoggerMethod} - The logger method or a no-op function.
+     * @private
+     */
+    private getExternalLoggerMethod;
+    /**
+     * Sets the logging level.
+     * @param {string} level - The logging level to set.
+     */
+    setLevel(level: string): void;
+    /**
+     * Sets an external logger to be used.
+     * @param {ExternalLogger | undefined | null} logger - The external logger to set.
+     */
+    setExternalLogger(logger: ExternalLogger | undefined | null, level?: LoggerLevel): void;
+    /**
+     * Logs the start of a function.
+     * @param {string} [functionName] - Optional function name to log.
+     */
+    logFunctionStart(functionName?: string): void;
+    /**
+     * Logs the end of a function.
+     * @param {string} [functionName] - Optional function name to log.
+     */
+    logFunctionEnd(functionName?: string): void;
+}
+export default SimpleLogger;