@decaf-ts/logging 0.3.8 → 0.3.10

package/lib/text.cjs

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringFormat = void 0;
+exports.padEnd = padEnd;
+exports.patchPlaceholders = patchPlaceholders;
+exports.patchString = patchString;
+exports.toCamelCase = toCamelCase;
+exports.toENVFormat = toENVFormat;
+exports.toSnakeCase = toSnakeCase;
+exports.toKebabCase = toKebabCase;
+exports.toPascalCase = toPascalCase;
+exports.escapeRegExp = escapeRegExp;
+exports.sf = sf;
+const constants_1 = require("./constants.cjs");
+/**
+ * @description Pads the end of a string with a specified character.
+ * @summary Extends the input string to a specified length by adding a padding character to the end.
+ * If the input string is already longer than the specified length, it is returned unchanged.
+ *
+ * @param {string} str - The input string to be padded.
+ * @param {number} length - The desired total length of the resulting string.
+ * @param {string} [char=" "] - The character to use for padding. Defaults to a space.
+ * @return {string} The padded string.
+ * @throws {Error} If the padding character is not exactly one character long.
+ *
+ * @function padEnd
+ *
+ * @memberOf module:Logging
+ */
+function padEnd(str, length, char = " ") {
+    if (char.length !== 1)
+        throw new Error("Invalid character length for padding. must be one!");
+    return str.padEnd(length, char);
+}
+/**
+ * @description Replaces placeholders in a string with provided values.
+ * @summary Interpolates a string by replacing placeholders of the form ${variableName}
+ * with corresponding values from the provided object. If a placeholder doesn't have
+ * a corresponding value, it is left unchanged in the string.
+ *
+ * @param {string} input - The input string containing placeholders to be replaced.
+ * @param {Record<string, number | string>} values - An object containing key-value pairs for replacement.
+ * @param prefix
+ * @param suffix
+ * @param flags
+ * @return {string} The interpolated string with placeholders replaced by their corresponding values.
+ *
+ * @function patchPlaceholders
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant patchString
+ *   participant String.replace
+ *   Caller->>patchString: Call with input and values
+ *   patchString->>String.replace: Call with regex and replacement function
+ *   String.replace->>patchString: Return replaced string
+ *   patchString-->>Caller: Return patched string
+ *
+ * @memberOf module:Logging
+ */
+function patchPlaceholders(input, values, prefix = constants_1.DefaultPlaceholderWrappers[0], suffix = constants_1.DefaultPlaceholderWrappers[1], flags = "g") {
+    const placeholders = Object.entries(values).reduce((acc, [key, val]) => {
+        acc[`${prefix}${key}${suffix}`] = val;
+        return acc;
+    }, {});
+    return patchString(input, placeholders, flags);
+}
+/**
+ * @description Replaces occurrences of keys with their corresponding values in a string.
+ * @summary Iterates through a set of key-value pairs and replaces all occurrences of each key
+ * in the input string with its corresponding value. Supports regular expression flags for customized replacement.
+ *
+ * @param {string} input - The input string in which replacements will be made.
+ * @param {Record<string, number | string>} values - An object containing key-value pairs for replacement.
+ * @param {string} [flags="g"] - Regular expression flags to control the replacement behavior.
+ * @return {string} The string with all specified replacements applied.
+ *
+ * @function patchString
+ *
+ * @memberOf module:Logging
+ */
+function patchString(input, values, flags = "g") {
+    Object.entries(values).forEach(([key, val]) => {
+        const regexp = new RegExp(escapeRegExp(key), flags);
+        input = input.replace(regexp, val);
+    });
+    return input;
+}
+/**
+ * @description Converts a string to camelCase.
+ * @summary Transforms the input string into camelCase format, where words are joined without spaces
+ * and each word after the first starts with a capital letter.
+ *
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to camelCase.
+ *
+ * @function toCamelCase
+ *
+ * @memberOf module:Logging
+ */
+function toCamelCase(text) {
+    return text
+        .replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => index === 0 ? word.toLowerCase() : word.toUpperCase())
+        .replace(/\s+/g, "");
+}
+/**
+ * @description Converts a string to ENVIRONMENT_VARIABLE format.
+ * @summary Transforms the input string into uppercase with words separated by underscores,
+ * typically used for environment variable names.
+ *
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to ENVIRONMENT_VARIABLE format.
+ *
+ * @function toENVFormat
+ *
+ * @memberOf module:Logging
+ */
+function toENVFormat(text) {
+    return toSnakeCase(text).toUpperCase();
+}
+/**
+ * @description Converts a string to snake_case.
+ * @summary Transforms the input string into lowercase with words separated by underscores.
+ *
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to snake_case.
+ *
+ * @function toSnakeCase
+ *
+ * @memberOf module:Logging
+ */
+function toSnakeCase(text) {
+    return text
+        .replace(/([a-z])([A-Z])/g, "$1_$2")
+        .replace(/[\s-]+/g, "_")
+        .toLowerCase();
+}
+/**
+ * @description Converts a string to kebab-case.
+ * @summary Transforms the input string into lowercase with words separated by hyphens.
+ *
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to kebab-case.
+ *
+ * @function toKebabCase
+ *
+ * @memberOf module:Logging
+ */
+function toKebabCase(text) {
+    return text
+        .replace(/([a-z])([A-Z])/g, "$1-$2")
+        .replace(/[\s_]+/g, "-")
+        .toLowerCase();
+}
+/**
+ * @description Converts a string to PascalCase.
+ * @summary Transforms the input string into PascalCase format, where words are joined without spaces
+ * and each word starts with a capital letter.
+ *
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to PascalCase.
+ *
+ * @function toPascalCase
+ *
+ * @memberOf module:Logging
+ */
+function toPascalCase(text) {
+    return text
+        .replace(/(?:^\w|[A-Z]|\b\w)/g, (word) => word.toUpperCase())
+        .replace(/\s+/g, "");
+}
+/**
+ * @description Escapes special characters in a string for use in a regular expression.
+ * @summary Adds backslashes before characters that have special meaning in regular expressions,
+ * allowing the string to be used as a literal match in a RegExp.
+ *
+ * @param {string} string - The string to escape for regular expression use.
+ * @return {string} The escaped string safe for use in regular expressions.
+ *
+ * @function escapeRegExp
+ *
+ * @memberOf module:Logging
+ */
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
+}
+/**
+ * @summary Util function to provide string format functionality similar to C#'s string.format
+ *
+ * @param {string} string
+ * @param {Array<string | number> | Record<string, any>} [args] replacements made by order of appearance (replacement0 wil replace {0} and so on)
+ * @return {string} formatted string
+ *
+ * @function sf
+ * @memberOf module:Logging
+ */
+function sf(string, ...args) {
+    if (args.length > 1) {
+        if (!args.every((arg) => typeof arg === "string" || typeof arg === "number"))
+            throw new Error(`Only string and number arguments are supported for multiple replacements.`);
+    }
+    if (args.length === 1 && typeof args[0] === "object") {
+        const obj = args[0];
+        return Object.entries(obj).reduce((acc, [key, val]) => {
+            return acc.replace(new RegExp(`\\{${key}\\}`, "g"), function () {
+                return val;
+            });
+        }, string);
+    }
+    return string.replace(/{(\d+)}/g, function (match, number) {
+        return typeof args[number] !== "undefined"
+            ? args[number].toString()
+            : "undefined";
+    });
+}
+/**
+ * @summary Util function to provide string format functionality similar to C#'s string.format
+ *
+ * @see sf
+ *
+ * @deprecated
+ * @function stringFormat
+ * @memberOf module:Logging
+ */
+exports.stringFormat = sf;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"text.js","sourceRoot":"","sources":["../src/text.ts"],"names":[],"mappings":"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","sourcesContent":["import { DefaultPlaceholderWrappers } from \"./constants\";\n\n/**\n * @description Pads the end of a string with a specified character.\n * @summary Extends the input string to a specified length by adding a padding character to the end.\n * If the input string is already longer than the specified length, it is returned unchanged.\n *\n * @param {string} str - The input string to be padded.\n * @param {number} length - The desired total length of the resulting string.\n * @param {string} [char=\" \"] - The character to use for padding. Defaults to a space.\n * @return {string} The padded string.\n * @throws {Error} If the padding character is not exactly one character long.\n *\n * @function padEnd\n *\n * @memberOf module:Logging\n */\nexport function padEnd(\n  str: string,\n  length: number,\n  char: string = \" \"\n): string {\n  if (char.length !== 1)\n    throw new Error(\"Invalid character length for padding. must be one!\");\n  return str.padEnd(length, char);\n}\n\n/**\n * @description Replaces placeholders in a string with provided values.\n * @summary Interpolates a string by replacing placeholders of the form ${variableName}\n * with corresponding values from the provided object. If a placeholder doesn't have\n * a corresponding value, it is left unchanged in the string.\n *\n * @param {string} input - The input string containing placeholders to be replaced.\n * @param {Record<string, number | string>} values - An object containing key-value pairs for replacement.\n * @param prefix\n * @param suffix\n * @param flags\n * @return {string} The interpolated string with placeholders replaced by their corresponding values.\n *\n * @function patchPlaceholders\n *\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant patchString\n *   participant String.replace\n *   Caller->>patchString: Call with input and values\n *   patchString->>String.replace: Call with regex and replacement function\n *   String.replace->>patchString: Return replaced string\n *   patchString-->>Caller: Return patched string\n *\n * @memberOf module:Logging\n */\nexport function patchPlaceholders(\n  input: string,\n  values: Record<string, number | string>,\n  prefix: string = DefaultPlaceholderWrappers[0],\n  suffix: string = DefaultPlaceholderWrappers[1],\n  flags: string = \"g\"\n): string {\n  const placeholders = Object.entries(values).reduce(\n    (acc: Record<string, any>, [key, val]) => {\n      acc[`${prefix}${key}${suffix}`] = val;\n      return acc;\n    },\n    {}\n  );\n  return patchString(input, placeholders, flags);\n}\n\n/**\n * @description Replaces occurrences of keys with their corresponding values in a string.\n * @summary Iterates through a set of key-value pairs and replaces all occurrences of each key\n * in the input string with its corresponding value. Supports regular expression flags for customized replacement.\n *\n * @param {string} input - The input string in which replacements will be made.\n * @param {Record<string, number | string>} values - An object containing key-value pairs for replacement.\n * @param {string} [flags=\"g\"] - Regular expression flags to control the replacement behavior.\n * @return {string} The string with all specified replacements applied.\n *\n * @function patchString\n *\n * @memberOf module:Logging\n */\nexport function patchString(\n  input: string,\n  values: Record<string, number | string>,\n  flags: string = \"g\"\n): string {\n  Object.entries(values).forEach(([key, val]) => {\n    const regexp = new RegExp(escapeRegExp(key), flags);\n    input = input.replace(regexp, val as string);\n  });\n  return input;\n}\n\n/**\n * @description Converts a string to camelCase.\n * @summary Transforms the input string into camelCase format, where words are joined without spaces\n * and each word after the first starts with a capital letter.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to camelCase.\n *\n * @function toCamelCase\n *\n * @memberOf module:Logging\n */\nexport function toCamelCase(text: string): string {\n  return text\n    .replace(/(?:^\\w|[A-Z]|\\b\\w)/g, (word, index) =>\n      index === 0 ? word.toLowerCase() : word.toUpperCase()\n    )\n    .replace(/\\s+/g, \"\");\n}\n\n/**\n * @description Converts a string to ENVIRONMENT_VARIABLE format.\n * @summary Transforms the input string into uppercase with words separated by underscores,\n * typically used for environment variable names.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to ENVIRONMENT_VARIABLE format.\n *\n * @function toENVFormat\n *\n * @memberOf module:Logging\n */\nexport function toENVFormat(text: string): string {\n  return toSnakeCase(text).toUpperCase();\n}\n\n/**\n * @description Converts a string to snake_case.\n * @summary Transforms the input string into lowercase with words separated by underscores.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to snake_case.\n *\n * @function toSnakeCase\n *\n * @memberOf module:Logging\n */\nexport function toSnakeCase(text: string): string {\n  return text\n    .replace(/([a-z])([A-Z])/g, \"$1_$2\")\n    .replace(/[\\s-]+/g, \"_\")\n    .toLowerCase();\n}\n\n/**\n * @description Converts a string to kebab-case.\n * @summary Transforms the input string into lowercase with words separated by hyphens.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to kebab-case.\n *\n * @function toKebabCase\n *\n * @memberOf module:Logging\n */\nexport function toKebabCase(text: string): string {\n  return text\n    .replace(/([a-z])([A-Z])/g, \"$1-$2\")\n    .replace(/[\\s_]+/g, \"-\")\n    .toLowerCase();\n}\n\n/**\n * @description Converts a string to PascalCase.\n * @summary Transforms the input string into PascalCase format, where words are joined without spaces\n * and each word starts with a capital letter.\n *\n * @param {string} text - The input string to be converted.\n * @return {string} The input string converted to PascalCase.\n *\n * @function toPascalCase\n *\n * @memberOf module:Logging\n */\nexport function toPascalCase(text: string): string {\n  return text\n    .replace(/(?:^\\w|[A-Z]|\\b\\w)/g, (word) => word.toUpperCase())\n    .replace(/\\s+/g, \"\");\n}\n\n/**\n * @description Escapes special characters in a string for use in a regular expression.\n * @summary Adds backslashes before characters that have special meaning in regular expressions,\n * allowing the string to be used as a literal match in a RegExp.\n *\n * @param {string} string - The string to escape for regular expression use.\n * @return {string} The escaped string safe for use in regular expressions.\n *\n * @function escapeRegExp\n *\n * @memberOf module:Logging\n */\nexport function escapeRegExp(string: string) {\n  return string.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\"); // $& means the whole matched string\n}\n\n/**\n * @summary Util function to provide string format functionality similar to C#'s string.format\n *\n * @param {string} string\n * @param {Array<string | number> | Record<string, any>} [args] replacements made by order of appearance (replacement0 wil replace {0} and so on)\n * @return {string} formatted string\n *\n * @function sf\n * @memberOf module:Logging\n */\nexport function sf(\n  string: string,\n  ...args: (string | number | Record<string, any>)[]\n) {\n  if (args.length > 1) {\n    if (\n      !args.every((arg) => typeof arg === \"string\" || typeof arg === \"number\")\n    )\n      throw new Error(\n        `Only string and number arguments are supported for multiple replacements.`\n      );\n  }\n\n  if (args.length === 1 && typeof args[0] === \"object\") {\n    const obj = args[0] as Record<string, any>;\n    return Object.entries(obj).reduce((acc, [key, val]) => {\n      return acc.replace(new RegExp(`\\\\{${key}\\\\}`, \"g\"), function () {\n        return val;\n      });\n    }, string);\n  }\n\n  return string.replace(/{(\\d+)}/g, function (match, number) {\n    return typeof args[number] !== \"undefined\"\n      ? args[number].toString()\n      : \"undefined\";\n  });\n}\n\n/**\n * @summary Util function to provide string format functionality similar to C#'s string.format\n *\n * @see sf\n *\n * @deprecated\n * @function stringFormat\n * @memberOf module:Logging\n */\nexport const stringFormat = sf;\n"]}

package/lib/text.d.ts

@@ -0,0 +1,156 @@
+/**
+ * @description Pads the end of a string with a specified character.
+ * @summary Extends the input string to a specified length by adding a padding character to the end.
+ * If the input string is already longer than the specified length, it is returned unchanged.
+ *
+ * @param {string} str - The input string to be padded.
+ * @param {number} length - The desired total length of the resulting string.
+ * @param {string} [char=" "] - The character to use for padding. Defaults to a space.
+ * @return {string} The padded string.
+ * @throws {Error} If the padding character is not exactly one character long.
+ *
+ * @function padEnd
+ *
+ * @memberOf module:Logging
+ */
+export declare function padEnd(str: string, length: number, char?: string): string;
+/**
+ * @description Replaces placeholders in a string with provided values.
+ * @summary Interpolates a string by replacing placeholders of the form ${variableName}
+ * with corresponding values from the provided object. If a placeholder doesn't have
+ * a corresponding value, it is left unchanged in the string.
+ *
+ * @param {string} input - The input string containing placeholders to be replaced.
+ * @param {Record<string, number | string>} values - An object containing key-value pairs for replacement.
+ * @param prefix
+ * @param suffix
+ * @param flags
+ * @return {string} The interpolated string with placeholders replaced by their corresponding values.
+ *
+ * @function patchPlaceholders
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant patchString
+ *   participant String.replace
+ *   Caller->>patchString: Call with input and values
+ *   patchString->>String.replace: Call with regex and replacement function
+ *   String.replace->>patchString: Return replaced string
+ *   patchString-->>Caller: Return patched string
+ *
+ * @memberOf module:Logging
+ */
+export declare function patchPlaceholders(input: string, values: Record<string, number | string>, prefix?: string, suffix?: string, flags?: string): string;
+/**
+ * @description Replaces occurrences of keys with their corresponding values in a string.
+ * @summary Iterates through a set of key-value pairs and replaces all occurrences of each key
+ * in the input string with its corresponding value. Supports regular expression flags for customized replacement.
+ *
+ * @param {string} input - The input string in which replacements will be made.
+ * @param {Record<string, number | string>} values - An object containing key-value pairs for replacement.
+ * @param {string} [flags="g"] - Regular expression flags to control the replacement behavior.
+ * @return {string} The string with all specified replacements applied.
+ *
+ * @function patchString
+ *
+ * @memberOf module:Logging
+ */
+export declare function patchString(input: string, values: Record<string, number | string>, flags?: string): string;
+/**
+ * @description Converts a string to camelCase.
+ * @summary Transforms the input string into camelCase format, where words are joined without spaces
+ * and each word after the first starts with a capital letter.
+ *
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to camelCase.
+ *
+ * @function toCamelCase
+ *
+ * @memberOf module:Logging
+ */
+export declare function toCamelCase(text: string): string;
+/**
+ * @description Converts a string to ENVIRONMENT_VARIABLE format.
+ * @summary Transforms the input string into uppercase with words separated by underscores,
+ * typically used for environment variable names.
+ *
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to ENVIRONMENT_VARIABLE format.
+ *
+ * @function toENVFormat
+ *
+ * @memberOf module:Logging
+ */
+export declare function toENVFormat(text: string): string;
+/**
+ * @description Converts a string to snake_case.
+ * @summary Transforms the input string into lowercase with words separated by underscores.
+ *
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to snake_case.
+ *
+ * @function toSnakeCase
+ *
+ * @memberOf module:Logging
+ */
+export declare function toSnakeCase(text: string): string;
+/**
+ * @description Converts a string to kebab-case.
+ * @summary Transforms the input string into lowercase with words separated by hyphens.
+ *
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to kebab-case.
+ *
+ * @function toKebabCase
+ *
+ * @memberOf module:Logging
+ */
+export declare function toKebabCase(text: string): string;
+/**
+ * @description Converts a string to PascalCase.
+ * @summary Transforms the input string into PascalCase format, where words are joined without spaces
+ * and each word starts with a capital letter.
+ *
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to PascalCase.
+ *
+ * @function toPascalCase
+ *
+ * @memberOf module:Logging
+ */
+export declare function toPascalCase(text: string): string;
+/**
+ * @description Escapes special characters in a string for use in a regular expression.
+ * @summary Adds backslashes before characters that have special meaning in regular expressions,
+ * allowing the string to be used as a literal match in a RegExp.
+ *
+ * @param {string} string - The string to escape for regular expression use.
+ * @return {string} The escaped string safe for use in regular expressions.
+ *
+ * @function escapeRegExp
+ *
+ * @memberOf module:Logging
+ */
+export declare function escapeRegExp(string: string): string;
+/**
+ * @summary Util function to provide string format functionality similar to C#'s string.format
+ *
+ * @param {string} string
+ * @param {Array<string | number> | Record<string, any>} [args] replacements made by order of appearance (replacement0 wil replace {0} and so on)
+ * @return {string} formatted string
+ *
+ * @function sf
+ * @memberOf module:Logging
+ */
+export declare function sf(string: string, ...args: (string | number | Record<string, any>)[]): string;
+/**
+ * @summary Util function to provide string format functionality similar to C#'s string.format
+ *
+ * @see sf
+ *
+ * @deprecated
+ * @function stringFormat
+ * @memberOf module:Logging
+ */
+export declare const stringFormat: typeof sf;

package/lib/types.cjs

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"","sourcesContent":["import { styles } from \"styled-string-builder\";\nimport { LoggingMode, LogLevel } from \"./constants\";\n\n/**\n * @description A type representing string-like values\n * @summary Represents either a string or an object with a toString method that returns a string\n * @typedef {(string|Object)} StringLike\n * @memberOf module:Logging\n */\nexport type StringLike = string | { toString: () => string };\n\n/**\n * @description A generic function type with any arguments and return\n * @summary Represents any callable signature, useful for annotating higher-order utilities\n * and dynamic method references where argument and return types are not constrained.\n * @typedef {Function} AnyFunction\n * @memberOf module:Logging\n */\nexport type AnyFunction = (...args: any[]) => any;\n\n/**\n * @description A constructable class type\n * @summary Describes a class constructor that produces instances of type T. Useful when\n * passing class references around (e.g., for context or dependency injection).\n * @template T\n * @typedef {function(any[]): T} Class\n * @memberOf module:Logging\n */\nexport type Class<T> = {\n  new (...args: any[]): T;\n};\n\n/**\n * @description A type representing logging context\n * @summary Represents a context for logging, which can be a string, a class constructor, or a function\n * @typedef {(string|Function|Object)} LoggingContext\n * @memberOf module:Logging\n */\nexport type LoggingContext = string | Class<any> | AnyFunction;\n\n/**\n * @description Interface for a logger with verbosity levels.\n * @summary Defines methods for logging at different verbosity levels.\n * @interface Logger\n * @memberOf module:Logging\n */\nexport interface Logger {\n  /**\n   * @description Logs a `way too verbose` or a silly message.\n   * @param {StringLike} msg - The message to log.\n   */\n  silly(msg: StringLike): void;\n  /**\n   * @description Logs a verbose message.\n   * @param {StringLike} msg - The message to log.\n   * @param {number} verbosity - The verbosity level of the message.\n   */\n  verbose(msg: StringLike, verbosity?: number): void;\n\n  /**\n   * @description Logs an info message.\n   * @param {StringLike} msg - The message to log.\n   */\n  info(msg: StringLike): void;\n\n  /**\n   * @description Logs an error message.\n   * @param {StringLike | Error} msg - The message to log.\n   */\n  error(msg: StringLike | Error): void;\n\n  /**\n   * @description Logs a debug message.\n   * @param {string} msg - The message to log.\n   */\n  debug(msg: StringLike): void;\n\n  /**\n   * @description Creates a new logger for a specific method or context\n   * @summary Returns a new logger instance that includes the specified method or context in its logs\n   * @param {string|Function} [method] - The method name or function to create a logger for\n   * @param {Partial<LoggingConfig>} [config] - Optional configuration for the new logger\n   * @return {Logger} A new logger instance\n   */\n  for(\n    method?: string | ((...args: any[]) => any),\n    config?: Partial<LoggingConfig>\n  ): Logger;\n\n  /**\n   * @description Updates the logger configuration\n   * @summary Sets or updates the configuration options for this logger instance\n   * @param {Partial<LoggingConfig>} config - The configuration options to apply\n   */\n  setConfig(config: Partial<LoggingConfig>): void;\n}\n\n/**\n * @description Configuration for logging.\n * @summary Defines the log level and verbosity for logging.\n * @typedef {Object} LoggingConfig\n * @property {LogLevel} level - The logging level.\n * @property {boolean} [logLevel] - Whether to display log level in output.\n * @property {number} verbose - The verbosity level.\n * @property {LoggingMode} [mode] - Output format mode.\n * @property {string} contextSeparator - Separator between context entries.\n * @property {string} separator - Separator between log components.\n * @property {boolean} [style] - Whether to apply styling to log output.\n * @property {boolean} [timestamp] - Whether to include timestamps in log messages.\n * @property {string} [timestampFormat] - Format for timestamps.\n * @property {boolean} [context] - Whether to include context information in log messages.\n * @property {Theme} [theme] - The theme to use for styling log messages.\n * @property {string|number} [correlationId] - Correlation ID for tracking related log messages.\n * @memberOf module:Logging\n */\nexport type LoggingConfig = {\n  level: LogLevel;\n  logLevel?: boolean;\n  verbose: number;\n  mode?: LoggingMode;\n  contextSeparator: string;\n  separator: string;\n  style?: boolean;\n  timestamp?: boolean;\n  timestampFormat?: string;\n  context?: boolean;\n  theme?: Theme;\n  format: \"raw\" | \"json\";\n  pattern: string;\n  correlationId?: string | number;\n};\n\n/**\n * @description A factory function type for creating loggers\n * @summary Defines a function type that creates and returns a logger instance for a given object\n * @template L - The logger type, extending the base Logger interface\n * @typedef {Function} LoggerFactory\n * @param {string} object - The object or context name for the logger\n * @param {Partial<LoggingConfig>} [config] - Optional configuration for the logger\n * @return {L} A logger instance\n * @memberOf module:Logging\n */\nexport type LoggerFactory<L extends Logger = Logger> = (\n  object: string,\n  config?: Partial<LoggingConfig>,\n  ...args: any[]\n) => L;\n\n/**\n * @description Represents a theme option for console output styling.\n * @summary Defines the structure for styling a specific element in the console output.\n * It allows for customization of foreground color, background color, and additional styles.\n * Colors can be specified as a single number, an RGB array, or left undefined for default.\n * @interface ThemeOption\n * @memberOf module:Logging\n */\nexport interface ThemeOption {\n  fg?: number | [number] | [number, number, number];\n\n  bg?: number | [number] | [number, number, number];\n\n  style?: number[] | [keyof typeof styles];\n}\n\n/**\n * @description A type for theme options organized by log level\n * @summary Defines a partial record mapping log levels to theme options, allowing different styling for different log levels\n * @typedef {Object} ThemeOptionByLogLevel\n * @memberOf module:Logging\n */\nexport type ThemeOptionByLogLevel = Partial<Record<LogLevel, ThemeOption>>;\n\n/**\n * @description Defines the color theme for console output.\n * @summary This interface specifies the color scheme for various elements of console output,\n * including styling for different log levels and components. It uses ThemeOption to\n * define the styling for each element, allowing for customization of colors and styles\n * for different parts of the log output.\n * @interface Theme\n * @memberOf module:Logging\n */\nexport interface Theme {\n  /**\n   * @description Styling for class names in the output.\n   */\n  class: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for timestamps in the output.\n   */\n  timestamp: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for the main message text in the output.\n   */\n  message: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for method names in the output.\n   */\n  method: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for identifier elements in the output.\n   */\n  id: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for identifier elements in the output.\n   */\n  stack: ThemeOption;\n\n  /**\n   * @description Styling for different log levels in the output.\n   */\n  logLevel: ThemeOptionByLogLevel;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"","sourcesContent":["import { styles } from \"styled-string-builder\";\nimport { LoggingMode, LogLevel } from \"./constants\";\n/**\n * @description A type representing string-like values\n * @summary Represents either a string or an object with a toString method that returns a string\n * @typedef {(string|Object)} StringLike\n * @memberOf module:Logging\n */\nexport type StringLike = string | { toString: () => string };\n\n/**\n * @description A generic function type with any arguments and return\n * @summary Represents any callable signature, useful for annotating higher-order utilities\n * and dynamic method references where argument and return types are not constrained.\n * @typedef {Function} AnyFunction\n * @memberOf module:Logging\n */\nexport type AnyFunction = (...args: any[]) => any;\n\n/**\n * @description A constructable class type\n * @summary Describes a class constructor that produces instances of type T. Useful when\n * passing class references around (e.g., for context or dependency injection).\n * @template T\n * @typedef {function(any[]): T} Class\n * @memberOf module:Logging\n */\nexport type Class<T> = {\n  new (...args: any[]): T;\n};\n\n/**\n * @description A type representing logging context\n * @summary Represents a context for logging, which can be a string, a class constructor, or a function\n * @typedef {(string|Function|Object)} LoggingContext\n * @memberOf module:Logging\n */\nexport type LoggingContext = string | Class<any> | AnyFunction;\n\nexport interface Impersonatable<THIS, ARGS extends any[] = any[]> {\n  for(...args: ARGS): THIS;\n}\n\n/**\n * @description Interface for a logger with verbosity levels.\n * @summary Defines methods for logging at different verbosity levels.\n * @interface Logger\n * @memberOf module:Logging\n */\nexport interface Logger\n  extends Impersonatable<\n    Logger,\n    [\n      (\n        | string\n        | { new (...args: any[]): any }\n        | AnyFunction\n        | Partial<LoggingConfig>\n      ),\n      Partial<LoggingConfig>,\n      ...any[],\n    ]\n  > {\n  /**\n   * @description Logs a `way too verbose` or a silly message.\n   * @param {StringLike} msg - The message to log.\n   */\n  silly(msg: StringLike): void;\n  /**\n   * @description Logs a verbose message.\n   * @param {StringLike} msg - The message to log.\n   * @param {number} verbosity - The verbosity level of the message.\n   */\n  verbose(msg: StringLike, verbosity?: number): void;\n\n  /**\n   * @description Logs an info message.\n   * @param {StringLike} msg - The message to log.\n   */\n  info(msg: StringLike): void;\n\n  /**\n   * @description Logs an error message.\n   * @param {StringLike | Error} msg - The message to log.\n   * @param e\n   */\n  error(msg: StringLike | Error, e?: Error): void;\n\n  /**\n   * @description Logs a debug message.\n   * @param {string} msg - The message to log.\n   */\n  debug(msg: StringLike): void;\n\n  /**\n   * @description Creates a new logger for a specific method or context\n   * @summary Returns a new logger instance that includes the specified method or context in its logs\n   * @param {string|Function} [method] - The method name or function to create a logger for\n   * @param {Partial<LoggingConfig>} [config] - Optional configuration for the new logger\n   * @param args\n   * @return {Logger} A new logger instance\n   */\n  for(\n    method:\n      | string\n      | { new (...args: any[]): any }\n      | AnyFunction\n      | Partial<LoggingConfig>,\n    config?: Partial<LoggingConfig>,\n    ...args: any[]\n  ): Logger;\n\n  /**\n   * @description Updates the logger configuration\n   * @summary Sets or updates the configuration options for this logger instance\n   * @param {Partial<LoggingConfig>} config - The configuration options to apply\n   */\n  setConfig(config: Partial<LoggingConfig>): void;\n}\n\nexport interface LoggingFilter {\n  filter(config: LoggingConfig, message: string, context: string[]): string;\n}\n\n/**\n * @description Configuration for logging.\n * @summary Defines the log level and verbosity for logging.\n * @typedef {Object} LoggingConfig\n * @property {LogLevel} level - The logging level.\n * @property {boolean} [logLevel] - Whether to display log level in output.\n * @property {number} verbose - The verbosity level.\n * @property {LoggingMode} [mode] - Output format mode.\n * @property {string} contextSeparator - Separator between context entries.\n * @property {string} separator - Separator between log components.\n * @property {boolean} [style] - Whether to apply styling to log output.\n * @property {boolean} [timestamp] - Whether to include timestamps in log messages.\n * @property {string} [timestampFormat] - Format for timestamps.\n * @property {boolean} [context] - Whether to include context information in log messages.\n * @property {Theme} [theme] - The theme to use for styling log messages.\n * @property {string|number} [correlationId] - Correlation ID for tracking related log messages.\n * @memberOf module:Logging\n */\nexport type LoggingConfig = {\n  app?: string;\n  env: \"development\" | \"production\" | \"test\" | \"staging\" | string;\n  level: LogLevel;\n  logLevel?: boolean;\n  verbose: number;\n  contextSeparator: string;\n  separator: string;\n  style?: boolean;\n  timestamp?: boolean;\n  timestampFormat?: string;\n  context?: boolean;\n  theme?: Theme;\n  format: LoggingMode;\n  pattern: string;\n  correlationId?: string | number;\n  filters?: string[] | LoggingFilter[];\n};\n\n/**\n * @description A factory function type for creating loggers\n * @summary Defines a function type that creates and returns a logger instance for a given object\n * @template L - The logger type, extending the base Logger interface\n * @typedef {Function} LoggerFactory\n * @param {string} object - The object or context name for the logger\n * @param {Partial<LoggingConfig>} [config] - Optional configuration for the logger\n * @return {L} A logger instance\n * @memberOf module:Logging\n */\nexport type LoggerFactory<L extends Logger = Logger> = (\n  object: string,\n  config?: Partial<LoggingConfig>,\n  ...args: any[]\n) => L;\n\n/**\n * @description Represents a theme option for console output styling.\n * @summary Defines the structure for styling a specific element in the console output.\n * It allows for customization of foreground color, background color, and additional styles.\n * Colors can be specified as a single number, an RGB array, or left undefined for default.\n * @interface ThemeOption\n * @memberOf module:Logging\n */\nexport interface ThemeOption {\n  fg?: number | [number] | [number, number, number];\n\n  bg?: number | [number] | [number, number, number];\n\n  style?: number[] | [keyof typeof styles];\n}\n\n/**\n * @description A type for theme options organized by log level\n * @summary Defines a partial record mapping log levels to theme options, allowing different styling for different log levels\n * @typedef {Object} ThemeOptionByLogLevel\n * @memberOf module:Logging\n */\nexport type ThemeOptionByLogLevel = Partial<Record<LogLevel, ThemeOption>>;\n\n/**\n * @description Defines the color theme for console output.\n * @summary This interface specifies the color scheme for various elements of console output,\n * including styling for different log levels and components. It uses ThemeOption to\n * define the styling for each element, allowing for customization of colors and styles\n * for different parts of the log output.\n * @interface Theme\n * @memberOf module:Logging\n */\nexport interface Theme {\n  /**\n   * @description Styling for class names in the output.\n   */\n  app: ThemeOption | ThemeOptionByLogLevel;\n  /**\n   * @description Styling for class names in the output.\n   */\n  separator: ThemeOption | ThemeOptionByLogLevel;\n  /**\n   * @description Styling for class names in the output.\n   */\n  class: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for timestamps in the output.\n   */\n  timestamp: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for the main message text in the output.\n   */\n  message: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for method names in the output.\n   */\n  method: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for identifier elements in the output.\n   */\n  id: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for identifier elements in the output.\n   */\n  stack: ThemeOption;\n\n  /**\n   * @description Styling for different log levels in the output.\n   */\n  logLevel: ThemeOptionByLogLevel;\n}\n"]}

package/lib/types.d.ts

@@ -35,13 +35,22 @@ export type Class<T> = {
  * @memberOf module:Logging
  */
 export type LoggingContext = string | Class<any> | AnyFunction;
+export interface Impersonatable<THIS, ARGS extends any[] = any[]> {
+    for(...args: ARGS): THIS;
+}
 /**
  * @description Interface for a logger with verbosity levels.
  * @summary Defines methods for logging at different verbosity levels.
  * @interface Logger
  * @memberOf module:Logging
  */
-export interface Logger {
+export interface Logger extends Impersonatable<Logger, [
+    (string | {
+        new (...args: any[]): any;
+    } | AnyFunction | Partial<LoggingConfig>),
+    Partial<LoggingConfig>,
+    ...any[]
+]> {
     /**
      * @description Logs a `way too verbose` or a silly message.
      * @param {StringLike} msg - The message to log.
@@ -61,8 +70,9 @@ export interface Logger {
     /**
      * @description Logs an error message.
      * @param {StringLike | Error} msg - The message to log.
+     * @param e
      */
-    error(msg: StringLike | Error): void;
+    error(msg: StringLike | Error, e?: Error): void;
     /**
      * @description Logs a debug message.
      * @param {string} msg - The message to log.
@@ -73,9 +83,12 @@ export interface Logger {
      * @summary Returns a new logger instance that includes the specified method or context in its logs
      * @param {string|Function} [method] - The method name or function to create a logger for
      * @param {Partial<LoggingConfig>} [config] - Optional configuration for the new logger
+     * @param args
      * @return {Logger} A new logger instance
      */
-    for(method?: string | ((...args: any[]) => any), config?: Partial<LoggingConfig>): Logger;
+    for(method: string | {
+        new (...args: any[]): any;
+    } | AnyFunction | Partial<LoggingConfig>, config?: Partial<LoggingConfig>, ...args: any[]): Logger;
     /**
      * @description Updates the logger configuration
      * @summary Sets or updates the configuration options for this logger instance
@@ -83,6 +96,9 @@ export interface Logger {
      */
     setConfig(config: Partial<LoggingConfig>): void;
 }
+export interface LoggingFilter {
+    filter(config: LoggingConfig, message: string, context: string[]): string;
+}
 /**
  * @description Configuration for logging.
  * @summary Defines the log level and verbosity for logging.
@@ -102,10 +118,11 @@ export interface Logger {
  * @memberOf module:Logging
  */
 export type LoggingConfig = {
+    app?: string;
+    env: "development" | "production" | "test" | "staging" | string;
     level: LogLevel;
     logLevel?: boolean;
     verbose: number;
-    mode?: LoggingMode;
     contextSeparator: string;
     separator: string;
     style?: boolean;
@@ -113,9 +130,10 @@ export type LoggingConfig = {
     timestampFormat?: string;
     context?: boolean;
     theme?: Theme;
-    format: "raw" | "json";
+    format: LoggingMode;
     pattern: string;
     correlationId?: string | number;
+    filters?: string[] | LoggingFilter[];
 };
 /**
  * @description A factory function type for creating loggers
@@ -158,6 +176,14 @@ export type ThemeOptionByLogLevel = Partial<Record<LogLevel, ThemeOption>>;
  * @memberOf module:Logging
  */
 export interface Theme {
+    /**
+     * @description Styling for class names in the output.
+     */
+    app: ThemeOption | ThemeOptionByLogLevel;
+    /**
+     * @description Styling for class names in the output.
+     */
+    separator: ThemeOption | ThemeOptionByLogLevel;
     /**
      * @description Styling for class names in the output.
      */

package/lib/web.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBrowser = isBrowser;
+/**
+ * @description Determines if the current environment is a browser by checking the prototype chain of the global object.
+ * @summary Checks if the code is running in a browser environment.
+ * @return {boolean} True if the environment is a browser, false otherwise.
+ * @function isBrowser
+ * @memberOf module:Logging
+ */
+function isBrowser() {
+    return (Object.getPrototypeOf(Object.getPrototypeOf(globalThis)) !==
+        Object.prototype);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2ViLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3dlYi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQU9BLDhCQUtDO0FBWkQ7Ozs7OztHQU1HO0FBQ0gsU0FBZ0IsU0FBUztJQUN2QixPQUFPLENBQ0wsTUFBTSxDQUFDLGNBQWMsQ0FBQyxNQUFNLENBQUMsY0FBYyxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQ3hELE1BQU0sQ0FBQyxTQUFTLENBQ2pCLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAZGVzY3JpcHRpb24gRGV0ZXJtaW5lcyBpZiB0aGUgY3VycmVudCBlbnZpcm9ubWVudCBpcyBhIGJyb3dzZXIgYnkgY2hlY2tpbmcgdGhlIHByb3RvdHlwZSBjaGFpbiBvZiB0aGUgZ2xvYmFsIG9iamVjdC5cbiAqIEBzdW1tYXJ5IENoZWNrcyBpZiB0aGUgY29kZSBpcyBydW5uaW5nIGluIGEgYnJvd3NlciBlbnZpcm9ubWVudC5cbiAqIEByZXR1cm4ge2Jvb2xlYW59IFRydWUgaWYgdGhlIGVudmlyb25tZW50IGlzIGEgYnJvd3NlciwgZmFsc2Ugb3RoZXJ3aXNlLlxuICogQGZ1bmN0aW9uIGlzQnJvd3NlclxuICogQG1lbWJlck9mIG1vZHVsZTpMb2dnaW5nXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpc0Jyb3dzZXIoKTogYm9vbGVhbiB7XG4gIHJldHVybiAoXG4gICAgT2JqZWN0LmdldFByb3RvdHlwZU9mKE9iamVjdC5nZXRQcm90b3R5cGVPZihnbG9iYWxUaGlzKSkgIT09XG4gICAgT2JqZWN0LnByb3RvdHlwZVxuICApO1xufVxuIl19

package/lib/web.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @description Determines if the current environment is a browser by checking the prototype chain of the global object.
+ * @summary Checks if the code is running in a browser environment.
+ * @return {boolean} True if the environment is a browser, false otherwise.
+ * @function isBrowser
+ * @memberOf module:Logging
+ */
+export declare function isBrowser(): boolean;

package/lib/winston/winston.cjs

@@ -61,13 +61,13 @@ class WinstonLogger extends logging_1.MiniLogger {
      * @summary Overrides the base log method to use Winston for logging
      * @param {LogLevel} level - The log level of the message
      * @param {StringLike | Error} msg - The message to be logged or an Error object
-     * @param {string} [stack] - Optional stack trace to include in the log
+     * @param {Error} [error] - Optional stack trace to include in the log
      * @return {void}
      */
-    log(level, msg, stack) {
+    log(level, msg, error) {
         const logData = {
             level: level,
-            message: this.createLog(level, msg, stack),
+            message: this.createLog(level, msg, error),
         };
         if (this.config("correlationId"))
             logData["correlationId"] = this.config("correlationId");
@@ -88,4 +88,4 @@ exports.WinstonLogger = WinstonLogger;
  */
 const WinstonFactory = (context, conf, ...args) => new WinstonLogger(context, conf, ...args);
 exports.WinstonFactory = WinstonFactory;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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