@decaf-ts/logging 0.0.17 → 0.1.0

package/dist/logging.cjs

@@ -0,0 +1,179 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.logging = {}));
+})(this, (function (exports) { 'use strict';
+
+    exports.LogLevel = void 0;
+    (function (LogLevel) {
+        LogLevel["Fatal"] = "fatal";
+        LogLevel["Error"] = "error";
+        LogLevel["Warn"] = "warn";
+        LogLevel["Info"] = "info";
+        LogLevel["Http"] = "http";
+        LogLevel["Verbose"] = "verbose";
+        LogLevel["Debug"] = "debug";
+        LogLevel["Silly"] = "silly";
+    })(exports.LogLevel || (exports.LogLevel = {}));
+    const NumericLogLevels = {
+        error: 0,
+        warn: 1,
+        info: 2,
+        http: 3,
+        verbose: 4,
+        debug: 5,
+        silly: 6,
+    };
+
+    class LoggerFactory {
+        constructor(level) {
+            this.level = level;
+        }
+    }
+
+    function toLogLevel(level) {
+        if (level.toString() in NumericLogLevels) {
+            return NumericLogLevels[level.toString()];
+        }
+        throw new Error(`Invalid level: ${level.toString()}`);
+    }
+
+    class DefaultLogger {
+        constructor(level, clazz, method) {
+            this.level = level;
+            this.clazz = clazz;
+            this.method = method;
+        }
+        log(level, message, data, profile) {
+            if (toLogLevel(level) < toLogLevel(this.level))
+                return;
+            const { context, app } = data || {};
+            const msg = `${profile ? `[${profile}]` : ""}${app ? `[${app}]` : ""}${context ? `[${context}]` : ""}${this.clazz ? `[${this.clazz}]` : ""}${this.method ? `[${this.method}]` : ""} ${message}`;
+            switch (level) {
+                case exports.LogLevel.Fatal:
+                case exports.LogLevel.Error:
+                    return console.error(msg);
+                case exports.LogLevel.Warn:
+                    return console.warn(msg);
+                case exports.LogLevel.Info:
+                    return console.info(msg);
+                case exports.LogLevel.Http:
+                case exports.LogLevel.Verbose:
+                case exports.LogLevel.Debug:
+                case exports.LogLevel.Silly:
+                    return console.debug(msg);
+                default:
+                    throw new Error(`Invalid log level: ${level}`);
+            }
+        }
+        silly(message, data, profile) {
+            return this.log(exports.LogLevel.Silly, message, data, profile);
+        }
+        verbose(message, data, profile) {
+            return this.log(exports.LogLevel.Verbose, message, data, profile);
+        }
+        debug(message, data, profile) {
+            return this.log(exports.LogLevel.Debug, message, data, profile);
+        }
+        info(message, data, profile) {
+            return this.log(exports.LogLevel.Info, message, data, profile);
+        }
+        warn(message, data, profile) {
+            return this.log(exports.LogLevel.Warn, message, data, profile);
+        }
+        error(message, data, profile) {
+            return this.log(exports.LogLevel.Error, message, data, profile);
+        }
+        emerg(message, data, profile) {
+            return this.log(exports.LogLevel.Fatal, message, data, profile);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        profile(id, meta) {
+            throw new Error("Not implemented");
+        }
+    }
+    class DefaultLoggerFactory extends LoggerFactory {
+        constructor(level) {
+            super(level);
+        }
+        forClass(clazz) {
+            return new DefaultLogger(this.level, clazz.name);
+        }
+        forMethod(clazz, method) {
+            return new DefaultLogger(this.level, clazz.name, typeof method === "string" ? method : method.name);
+        }
+        get() {
+            return new DefaultLogger(this.level);
+        }
+    }
+
+    class Logging {
+        static { this._level = exports.LogLevel.Info; }
+        static { this._factory = DefaultLoggerFactory; }
+        static { this.cacheByClass = {}; }
+        static { this.cacheByClassMethod = {}; }
+        constructor() { }
+        static get level() {
+            return this._level;
+        }
+        static set level(level) {
+            this._level = level;
+        }
+        static get instance() {
+            if (!this._instance)
+                this._instance = new this._factory(Logging.level);
+            return this._instance;
+        }
+        static set factory(factory) {
+            this._factory = factory;
+        }
+        static forClass(clazz) {
+            const name = clazz.name;
+            if (!(name in this.cacheByClass))
+                this.cacheByClass[name] = Logging.instance.forClass(clazz);
+            return this.cacheByClass[name];
+        }
+        static forMethod(clazz, method) {
+            const name = clazz.name;
+            if (!(name in this.cacheByClassMethod))
+                this.cacheByClassMethod[name] = {};
+            const methodName = typeof method === "string" ? method : method.name;
+            if (!(methodName in this.cacheByClassMethod[name]))
+                this.cacheByClassMethod[name][methodName] = Logging.instance.forMethod(clazz, method);
+            return this.cacheByClassMethod[name][methodName];
+        }
+        static get() {
+            if (!this.global)
+                this.global = Logging.instance.get();
+            return this.global;
+        }
+    }
+
+    /**
+     * @summary Module summary
+     * @description Module description
+     * @module Logging
+     */
+    /**
+     * @summary Logging
+     * @description Namespace description
+     * @namespace Logging
+     * @memberOf module:Logging
+     */
+    /**
+     * @summary stores the current package version
+     * @description this is how you should document a constant
+     * @const VERSION
+     * @memberOf module:ts-workspace
+     */
+    const VERSION = "0.1.0";
+
+    exports.DefaultLoggerFactory = DefaultLoggerFactory;
+    exports.LoggerFactory = LoggerFactory;
+    exports.Logging = Logging;
+    exports.NumericLogLevels = NumericLogLevels;
+    exports.VERSION = VERSION;
+    exports.toLogLevel = toLogLevel;
+
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"logging.cjs","sources":["../src/constants.ts","../src/Factory.ts","../src/utils.ts","../src/default.ts","../src/logging.ts","../src/index.ts"],"sourcesContent":["export enum LogLevel {\n  Fatal = \"fatal\", // A person must take an action immediately\n  Error = \"error\", // Error events are likely to cause problems\n  Warn = \"warn\", // Warning events might cause problems in the future and deserve eyes\n  Info = \"info\", // Routine information, such as ongoing status or performance\n  Http = \"http\", // Http information\n  Verbose = \"verbose\", // Debug or trace information\n  Debug = \"debug\", // Debug or trace information\n  Silly = \"silly\", // Debug or trace information\n}\n\nexport const NumericLogLevels = {\n  error: 0,\n  warn: 1,\n  info: 2,\n  http: 3,\n  verbose: 4,\n  debug: 5,\n  silly: 6,\n};\n","import { Logger } from \"./interfaces\";\nimport { LogLevel } from \"./constants\";\n\nexport abstract class LoggerFactory {\n  protected constructor(protected level: LogLevel) {}\n  abstract forClass(clazz: { new (...args: any[]): any }): Logger;\n  abstract forMethod(\n    clazz: { new (...args: any[]): any },\n    method: ((...args: any[]) => any) | string\n  ): Logger;\n  abstract get(): Logger;\n}\n","import { LogLevel, NumericLogLevels } from \"./constants\";\n\nexport function toLogLevel(level: LogLevel): number {\n  if (level.toString() in NumericLogLevels) {\n    return (NumericLogLevels as Record<string, any>)[level.toString()];\n  }\n  throw new Error(`Invalid level: ${level.toString()}`);\n}\n","import { LoggerFactory } from \"./Factory\";\nimport { LogLevel } from \"./constants\";\nimport { LogData, Logger } from \"./interfaces\";\nimport { toLogLevel } from \"./utils\";\n\nclass DefaultLogger implements Logger {\n  constructor(\n    protected level: LogLevel,\n    protected clazz?: string,\n    protected method?: string\n  ) {}\n\n  log(\n    level: LogLevel,\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    if (toLogLevel(level) < toLogLevel(this.level)) return;\n\n    const { context, app } = data || {};\n\n     \n    const msg = `${profile ? `[${profile}]` : \"\"}${app ? `[${app}]` : \"\"}${context ? `[${context}]` : \"\"}${this.clazz ? `[${this.clazz}]` : \"\"}${this.method ? `[${this.method}]` : \"\"} ${message}`;\n    switch (level) {\n    case LogLevel.Fatal:\n    case LogLevel.Error:\n      return console.error(msg);\n    case LogLevel.Warn:\n      return console.warn(msg);\n    case LogLevel.Info:\n      return console.info(msg);\n    case LogLevel.Http:\n    case LogLevel.Verbose:\n    case LogLevel.Debug:\n    case LogLevel.Silly:\n      return console.debug(msg);\n    default:\n      throw new Error(`Invalid log level: ${level}`);\n    }\n  }\n  silly(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Silly, message, data, profile);\n  }\n\n  verbose(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Verbose, message, data, profile);\n  }\n\n  debug(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Debug, message, data, profile);\n  }\n  info(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Info, message, data, profile);\n  }\n  warn(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Warn, message, data, profile);\n  }\n  error(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Error, message, data, profile);\n  }\n  emerg(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Fatal, message, data, profile);\n  }\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  profile(id: string | number, meta?: Record<string, any> | undefined): void {\n    throw new Error(\"Not implemented\");\n  }\n}\n\nexport class DefaultLoggerFactory extends LoggerFactory {\n  constructor(level: LogLevel) {\n    super(level);\n  }\n\n  forClass(clazz: new (...args: any[]) => any): Logger {\n    return new DefaultLogger(this.level, clazz.name);\n  }\n  forMethod(\n    clazz: new (...args: any[]) => any,\n    method: string | ((...args: any[]) => any)\n  ): Logger {\n    return new DefaultLogger(\n      this.level,\n      clazz.name,\n      typeof method === \"string\" ? method : method.name\n    );\n  }\n\n  get(): Logger {\n    return new DefaultLogger(this.level);\n  }\n}\n","import { Logger } from \"./interfaces\";\nimport { LoggerFactory } from \"./Factory\";\nimport { LogLevel } from \"./constants\";\nimport { DefaultLoggerFactory } from \"./default\";\n\nexport class Logging {\n  private static _level: LogLevel = LogLevel.Info;\n  private static _factory: { new (level: LogLevel): LoggerFactory } =\n    DefaultLoggerFactory;\n  private static _instance: LoggerFactory;\n\n  private static cacheByClass: Record<string, Logger> = {};\n  private static cacheByClassMethod: Record<string, Record<string, Logger>> =\n    {};\n  private static global: Logger;\n\n  private constructor() {}\n\n  static get level() {\n    return this._level;\n  }\n\n  static set level(level: LogLevel) {\n    this._level = level;\n  }\n\n  protected static get instance(): LoggerFactory {\n    if (!this._instance) this._instance = new this._factory(Logging.level);\n    return this._instance;\n  }\n\n  static set factory(factory: { new (level: LogLevel): LoggerFactory }) {\n    this._factory = factory;\n  }\n\n  static forClass(clazz: { new (...args: any[]): any }) {\n    const name = clazz.name;\n    if (!(name in this.cacheByClass))\n      this.cacheByClass[name] = Logging.instance.forClass(clazz);\n    return this.cacheByClass[name];\n  }\n\n  static forMethod(\n    clazz: { new (...args: any[]): any },\n    method: ((...args: any[]) => any) | string\n  ): Logger {\n    const name = clazz.name;\n    if (!(name in this.cacheByClassMethod)) this.cacheByClassMethod[name] = {};\n    const methodName = typeof method === \"string\" ? method : method.name;\n    if (!(methodName in this.cacheByClassMethod[name]))\n      this.cacheByClassMethod[name][methodName] = Logging.instance.forMethod(\n        clazz,\n        method\n      );\n    return this.cacheByClassMethod[name][methodName];\n  }\n\n  static get(): Logger {\n    if (!this.global) this.global = Logging.instance.get();\n    return this.global;\n  }\n}\n","export * from \"./constants\";\nexport * from \"./default\";\nexport * from \"./Factory\";\nexport * from \"./interfaces\";\nexport * from \"./logging\";\nexport * from \"./utils\";\n\n/**\n * @summary Module summary\n * @description Module description\n * @module Logging\n */\n\n/**\n * @summary Logging\n * @description Namespace description\n * @namespace Logging\n * @memberOf module:Logging\n */\n\n/**\n * @summary stores the current package version\n * @description this is how you should document a constant\n * @const VERSION\n * @memberOf module:ts-workspace\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["LogLevel"],"mappings":"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"}

package/dist/logging.esm.cjs

@@ -0,0 +1,166 @@
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["Fatal"] = "fatal";
+    LogLevel["Error"] = "error";
+    LogLevel["Warn"] = "warn";
+    LogLevel["Info"] = "info";
+    LogLevel["Http"] = "http";
+    LogLevel["Verbose"] = "verbose";
+    LogLevel["Debug"] = "debug";
+    LogLevel["Silly"] = "silly";
+})(LogLevel || (LogLevel = {}));
+const NumericLogLevels = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    http: 3,
+    verbose: 4,
+    debug: 5,
+    silly: 6,
+};
+
+class LoggerFactory {
+    constructor(level) {
+        this.level = level;
+    }
+}
+
+function toLogLevel(level) {
+    if (level.toString() in NumericLogLevels) {
+        return NumericLogLevels[level.toString()];
+    }
+    throw new Error(`Invalid level: ${level.toString()}`);
+}
+
+class DefaultLogger {
+    constructor(level, clazz, method) {
+        this.level = level;
+        this.clazz = clazz;
+        this.method = method;
+    }
+    log(level, message, data, profile) {
+        if (toLogLevel(level) < toLogLevel(this.level))
+            return;
+        const { context, app } = data || {};
+        const msg = `${profile ? `[${profile}]` : ""}${app ? `[${app}]` : ""}${context ? `[${context}]` : ""}${this.clazz ? `[${this.clazz}]` : ""}${this.method ? `[${this.method}]` : ""} ${message}`;
+        switch (level) {
+            case LogLevel.Fatal:
+            case LogLevel.Error:
+                return console.error(msg);
+            case LogLevel.Warn:
+                return console.warn(msg);
+            case LogLevel.Info:
+                return console.info(msg);
+            case LogLevel.Http:
+            case LogLevel.Verbose:
+            case LogLevel.Debug:
+            case LogLevel.Silly:
+                return console.debug(msg);
+            default:
+                throw new Error(`Invalid log level: ${level}`);
+        }
+    }
+    silly(message, data, profile) {
+        return this.log(LogLevel.Silly, message, data, profile);
+    }
+    verbose(message, data, profile) {
+        return this.log(LogLevel.Verbose, message, data, profile);
+    }
+    debug(message, data, profile) {
+        return this.log(LogLevel.Debug, message, data, profile);
+    }
+    info(message, data, profile) {
+        return this.log(LogLevel.Info, message, data, profile);
+    }
+    warn(message, data, profile) {
+        return this.log(LogLevel.Warn, message, data, profile);
+    }
+    error(message, data, profile) {
+        return this.log(LogLevel.Error, message, data, profile);
+    }
+    emerg(message, data, profile) {
+        return this.log(LogLevel.Fatal, message, data, profile);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    profile(id, meta) {
+        throw new Error("Not implemented");
+    }
+}
+class DefaultLoggerFactory extends LoggerFactory {
+    constructor(level) {
+        super(level);
+    }
+    forClass(clazz) {
+        return new DefaultLogger(this.level, clazz.name);
+    }
+    forMethod(clazz, method) {
+        return new DefaultLogger(this.level, clazz.name, typeof method === "string" ? method : method.name);
+    }
+    get() {
+        return new DefaultLogger(this.level);
+    }
+}
+
+class Logging {
+    static { this._level = LogLevel.Info; }
+    static { this._factory = DefaultLoggerFactory; }
+    static { this.cacheByClass = {}; }
+    static { this.cacheByClassMethod = {}; }
+    constructor() { }
+    static get level() {
+        return this._level;
+    }
+    static set level(level) {
+        this._level = level;
+    }
+    static get instance() {
+        if (!this._instance)
+            this._instance = new this._factory(Logging.level);
+        return this._instance;
+    }
+    static set factory(factory) {
+        this._factory = factory;
+    }
+    static forClass(clazz) {
+        const name = clazz.name;
+        if (!(name in this.cacheByClass))
+            this.cacheByClass[name] = Logging.instance.forClass(clazz);
+        return this.cacheByClass[name];
+    }
+    static forMethod(clazz, method) {
+        const name = clazz.name;
+        if (!(name in this.cacheByClassMethod))
+            this.cacheByClassMethod[name] = {};
+        const methodName = typeof method === "string" ? method : method.name;
+        if (!(methodName in this.cacheByClassMethod[name]))
+            this.cacheByClassMethod[name][methodName] = Logging.instance.forMethod(clazz, method);
+        return this.cacheByClassMethod[name][methodName];
+    }
+    static get() {
+        if (!this.global)
+            this.global = Logging.instance.get();
+        return this.global;
+    }
+}
+
+/**
+ * @summary Module summary
+ * @description Module description
+ * @module Logging
+ */
+/**
+ * @summary Logging
+ * @description Namespace description
+ * @namespace Logging
+ * @memberOf module:Logging
+ */
+/**
+ * @summary stores the current package version
+ * @description this is how you should document a constant
+ * @const VERSION
+ * @memberOf module:ts-workspace
+ */
+const VERSION = "0.1.0";
+
+export { DefaultLoggerFactory, LogLevel, LoggerFactory, Logging, NumericLogLevels, VERSION, toLogLevel };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"logging.esm.cjs","sources":["../src/constants.ts","../src/Factory.ts","../src/utils.ts","../src/default.ts","../src/logging.ts","../src/index.ts"],"sourcesContent":["export enum LogLevel {\n  Fatal = \"fatal\", // A person must take an action immediately\n  Error = \"error\", // Error events are likely to cause problems\n  Warn = \"warn\", // Warning events might cause problems in the future and deserve eyes\n  Info = \"info\", // Routine information, such as ongoing status or performance\n  Http = \"http\", // Http information\n  Verbose = \"verbose\", // Debug or trace information\n  Debug = \"debug\", // Debug or trace information\n  Silly = \"silly\", // Debug or trace information\n}\n\nexport const NumericLogLevels = {\n  error: 0,\n  warn: 1,\n  info: 2,\n  http: 3,\n  verbose: 4,\n  debug: 5,\n  silly: 6,\n};\n","import { Logger } from \"./interfaces\";\nimport { LogLevel } from \"./constants\";\n\nexport abstract class LoggerFactory {\n  protected constructor(protected level: LogLevel) {}\n  abstract forClass(clazz: { new (...args: any[]): any }): Logger;\n  abstract forMethod(\n    clazz: { new (...args: any[]): any },\n    method: ((...args: any[]) => any) | string\n  ): Logger;\n  abstract get(): Logger;\n}\n","import { LogLevel, NumericLogLevels } from \"./constants\";\n\nexport function toLogLevel(level: LogLevel): number {\n  if (level.toString() in NumericLogLevels) {\n    return (NumericLogLevels as Record<string, any>)[level.toString()];\n  }\n  throw new Error(`Invalid level: ${level.toString()}`);\n}\n","import { LoggerFactory } from \"./Factory\";\nimport { LogLevel } from \"./constants\";\nimport { LogData, Logger } from \"./interfaces\";\nimport { toLogLevel } from \"./utils\";\n\nclass DefaultLogger implements Logger {\n  constructor(\n    protected level: LogLevel,\n    protected clazz?: string,\n    protected method?: string\n  ) {}\n\n  log(\n    level: LogLevel,\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    if (toLogLevel(level) < toLogLevel(this.level)) return;\n\n    const { context, app } = data || {};\n\n     \n    const msg = `${profile ? `[${profile}]` : \"\"}${app ? `[${app}]` : \"\"}${context ? `[${context}]` : \"\"}${this.clazz ? `[${this.clazz}]` : \"\"}${this.method ? `[${this.method}]` : \"\"} ${message}`;\n    switch (level) {\n    case LogLevel.Fatal:\n    case LogLevel.Error:\n      return console.error(msg);\n    case LogLevel.Warn:\n      return console.warn(msg);\n    case LogLevel.Info:\n      return console.info(msg);\n    case LogLevel.Http:\n    case LogLevel.Verbose:\n    case LogLevel.Debug:\n    case LogLevel.Silly:\n      return console.debug(msg);\n    default:\n      throw new Error(`Invalid log level: ${level}`);\n    }\n  }\n  silly(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Silly, message, data, profile);\n  }\n\n  verbose(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Verbose, message, data, profile);\n  }\n\n  debug(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Debug, message, data, profile);\n  }\n  info(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Info, message, data, profile);\n  }\n  warn(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Warn, message, data, profile);\n  }\n  error(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Error, message, data, profile);\n  }\n  emerg(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Fatal, message, data, profile);\n  }\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  profile(id: string | number, meta?: Record<string, any> | undefined): void {\n    throw new Error(\"Not implemented\");\n  }\n}\n\nexport class DefaultLoggerFactory extends LoggerFactory {\n  constructor(level: LogLevel) {\n    super(level);\n  }\n\n  forClass(clazz: new (...args: any[]) => any): Logger {\n    return new DefaultLogger(this.level, clazz.name);\n  }\n  forMethod(\n    clazz: new (...args: any[]) => any,\n    method: string | ((...args: any[]) => any)\n  ): Logger {\n    return new DefaultLogger(\n      this.level,\n      clazz.name,\n      typeof method === \"string\" ? method : method.name\n    );\n  }\n\n  get(): Logger {\n    return new DefaultLogger(this.level);\n  }\n}\n","import { Logger } from \"./interfaces\";\nimport { LoggerFactory } from \"./Factory\";\nimport { LogLevel } from \"./constants\";\nimport { DefaultLoggerFactory } from \"./default\";\n\nexport class Logging {\n  private static _level: LogLevel = LogLevel.Info;\n  private static _factory: { new (level: LogLevel): LoggerFactory } =\n    DefaultLoggerFactory;\n  private static _instance: LoggerFactory;\n\n  private static cacheByClass: Record<string, Logger> = {};\n  private static cacheByClassMethod: Record<string, Record<string, Logger>> =\n    {};\n  private static global: Logger;\n\n  private constructor() {}\n\n  static get level() {\n    return this._level;\n  }\n\n  static set level(level: LogLevel) {\n    this._level = level;\n  }\n\n  protected static get instance(): LoggerFactory {\n    if (!this._instance) this._instance = new this._factory(Logging.level);\n    return this._instance;\n  }\n\n  static set factory(factory: { new (level: LogLevel): LoggerFactory }) {\n    this._factory = factory;\n  }\n\n  static forClass(clazz: { new (...args: any[]): any }) {\n    const name = clazz.name;\n    if (!(name in this.cacheByClass))\n      this.cacheByClass[name] = Logging.instance.forClass(clazz);\n    return this.cacheByClass[name];\n  }\n\n  static forMethod(\n    clazz: { new (...args: any[]): any },\n    method: ((...args: any[]) => any) | string\n  ): Logger {\n    const name = clazz.name;\n    if (!(name in this.cacheByClassMethod)) this.cacheByClassMethod[name] = {};\n    const methodName = typeof method === \"string\" ? method : method.name;\n    if (!(methodName in this.cacheByClassMethod[name]))\n      this.cacheByClassMethod[name][methodName] = Logging.instance.forMethod(\n        clazz,\n        method\n      );\n    return this.cacheByClassMethod[name][methodName];\n  }\n\n  static get(): Logger {\n    if (!this.global) this.global = Logging.instance.get();\n    return this.global;\n  }\n}\n","export * from \"./constants\";\nexport * from \"./default\";\nexport * from \"./Factory\";\nexport * from \"./interfaces\";\nexport * from \"./logging\";\nexport * from \"./utils\";\n\n/**\n * @summary Module summary\n * @description Module description\n * @module Logging\n */\n\n/**\n * @summary Logging\n * @description Namespace description\n * @namespace Logging\n * @memberOf module:Logging\n */\n\n/**\n * @summary stores the current package version\n * @description this is how you should document a constant\n * @const VERSION\n * @memberOf module:ts-workspace\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":[],"mappings":"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"}

package/lib/Factory.cjs

@@ -7,5 +7,4 @@ class LoggerFactory {
     }
 }
 exports.LoggerFactory = LoggerFactory;
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9GYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUdBLE1BQXNCLGFBQWE7SUFDakMsWUFBZ0MsS0FBZTtRQUFmLFVBQUssR0FBTCxLQUFLLENBQVU7SUFBRyxDQUFDO0NBT3BEO0FBUkQsc0NBUUMiLCJmaWxlIjoiRmFjdG9yeS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IExvZ2dlciB9IGZyb20gXCIuL2ludGVyZmFjZXNcIjtcbmltcG9ydCB7IExvZ0xldmVsIH0gZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBMb2dnZXJGYWN0b3J5IHtcbiAgcHJvdGVjdGVkIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBsZXZlbDogTG9nTGV2ZWwpIHt9XG4gIGFic3RyYWN0IGZvckNsYXNzKGNsYXp6OiB7IG5ldyAoLi4uYXJnczogYW55W10pOiBhbnkgfSk6IExvZ2dlcjtcbiAgYWJzdHJhY3QgZm9yTWV0aG9kKFxuICAgIGNsYXp6OiB7IG5ldyAoLi4uYXJnczogYW55W10pOiBhbnkgfSxcbiAgICBtZXRob2Q6ICgoLi4uYXJnczogYW55W10pID0+IGFueSkgfCBzdHJpbmdcbiAgKTogTG9nZ2VyO1xuICBhYnN0cmFjdCBnZXQoKTogTG9nZ2VyO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRmFjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9GYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUdBLE1BQXNCLGFBQWE7SUFDakMsWUFBZ0MsS0FBZTtRQUFmLFVBQUssR0FBTCxLQUFLLENBQVU7SUFBRyxDQUFDO0NBT3BEO0FBUkQsc0NBUUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBMb2dnZXIgfSBmcm9tIFwiLi9pbnRlcmZhY2VzXCI7XG5pbXBvcnQgeyBMb2dMZXZlbCB9IGZyb20gXCIuL2NvbnN0YW50c1wiO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgTG9nZ2VyRmFjdG9yeSB7XG4gIHByb3RlY3RlZCBjb25zdHJ1Y3Rvcihwcm90ZWN0ZWQgbGV2ZWw6IExvZ0xldmVsKSB7fVxuICBhYnN0cmFjdCBmb3JDbGFzcyhjbGF6ejogeyBuZXcgKC4uLmFyZ3M6IGFueVtdKTogYW55IH0pOiBMb2dnZXI7XG4gIGFic3RyYWN0IGZvck1ldGhvZChcbiAgICBjbGF6ejogeyBuZXcgKC4uLmFyZ3M6IGFueVtdKTogYW55IH0sXG4gICAgbWV0aG9kOiAoKC4uLmFyZ3M6IGFueVtdKSA9PiBhbnkpIHwgc3RyaW5nXG4gICk6IExvZ2dlcjtcbiAgYWJzdHJhY3QgZ2V0KCk6IExvZ2dlcjtcbn1cbiJdfQ==

package/lib/constants.cjs

@@ -21,5 +21,4 @@ exports.NumericLogLevels = {
     debug: 5,
     silly: 6,
 };
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsSUFBWSxRQVNYO0FBVEQsV0FBWSxRQUFRO0lBQ2xCLDJCQUFlLENBQUE7SUFDZiwyQkFBZSxDQUFBO0lBQ2YseUJBQWEsQ0FBQTtJQUNiLHlCQUFhLENBQUE7SUFDYix5QkFBYSxDQUFBO0lBQ2IsK0JBQW1CLENBQUE7SUFDbkIsMkJBQWUsQ0FBQTtJQUNmLDJCQUFlLENBQUE7QUFDakIsQ0FBQyxFQVRXLFFBQVEsd0JBQVIsUUFBUSxRQVNuQjtBQUVZLFFBQUEsZ0JBQWdCLEdBQUc7SUFDOUIsS0FBSyxFQUFFLENBQUM7SUFDUixJQUFJLEVBQUUsQ0FBQztJQUNQLElBQUksRUFBRSxDQUFDO0lBQ1AsSUFBSSxFQUFFLENBQUM7SUFDUCxPQUFPLEVBQUUsQ0FBQztJQUNWLEtBQUssRUFBRSxDQUFDO0lBQ1IsS0FBSyxFQUFFLENBQUM7Q0FDVCxDQUFDIiwiZmlsZSI6ImNvbnN0YW50cy5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIExvZ0xldmVsIHtcbiAgRmF0YWwgPSBcImZhdGFsXCIsIC8vIEEgcGVyc29uIG11c3QgdGFrZSBhbiBhY3Rpb24gaW1tZWRpYXRlbHlcbiAgRXJyb3IgPSBcImVycm9yXCIsIC8vIEVycm9yIGV2ZW50cyBhcmUgbGlrZWx5IHRvIGNhdXNlIHByb2JsZW1zXG4gIFdhcm4gPSBcIndhcm5cIiwgLy8gV2FybmluZyBldmVudHMgbWlnaHQgY2F1c2UgcHJvYmxlbXMgaW4gdGhlIGZ1dHVyZSBhbmQgZGVzZXJ2ZSBleWVzXG4gIEluZm8gPSBcImluZm9cIiwgLy8gUm91dGluZSBpbmZvcm1hdGlvbiwgc3VjaCBhcyBvbmdvaW5nIHN0YXR1cyBvciBwZXJmb3JtYW5jZVxuICBIdHRwID0gXCJodHRwXCIsIC8vIEh0dHAgaW5mb3JtYXRpb25cbiAgVmVyYm9zZSA9IFwidmVyYm9zZVwiLCAvLyBEZWJ1ZyBvciB0cmFjZSBpbmZvcm1hdGlvblxuICBEZWJ1ZyA9IFwiZGVidWdcIiwgLy8gRGVidWcgb3IgdHJhY2UgaW5mb3JtYXRpb25cbiAgU2lsbHkgPSBcInNpbGx5XCIsIC8vIERlYnVnIG9yIHRyYWNlIGluZm9ybWF0aW9uXG59XG5cbmV4cG9ydCBjb25zdCBOdW1lcmljTG9nTGV2ZWxzID0ge1xuICBlcnJvcjogMCxcbiAgd2FybjogMSxcbiAgaW5mbzogMixcbiAgaHR0cDogMyxcbiAgdmVyYm9zZTogNCxcbiAgZGVidWc6IDUsXG4gIHNpbGx5OiA2LFxufTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxJQUFZLFFBU1g7QUFURCxXQUFZLFFBQVE7SUFDbEIsMkJBQWUsQ0FBQTtJQUNmLDJCQUFlLENBQUE7SUFDZix5QkFBYSxDQUFBO0lBQ2IseUJBQWEsQ0FBQTtJQUNiLHlCQUFhLENBQUE7SUFDYiwrQkFBbUIsQ0FBQTtJQUNuQiwyQkFBZSxDQUFBO0lBQ2YsMkJBQWUsQ0FBQTtBQUNqQixDQUFDLEVBVFcsUUFBUSx3QkFBUixRQUFRLFFBU25CO0FBRVksUUFBQSxnQkFBZ0IsR0FBRztJQUM5QixLQUFLLEVBQUUsQ0FBQztJQUNSLElBQUksRUFBRSxDQUFDO0lBQ1AsSUFBSSxFQUFFLENBQUM7SUFDUCxJQUFJLEVBQUUsQ0FBQztJQUNQLE9BQU8sRUFBRSxDQUFDO0lBQ1YsS0FBSyxFQUFFLENBQUM7SUFDUixLQUFLLEVBQUUsQ0FBQztDQUNULENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBMb2dMZXZlbCB7XG4gIEZhdGFsID0gXCJmYXRhbFwiLCAvLyBBIHBlcnNvbiBtdXN0IHRha2UgYW4gYWN0aW9uIGltbWVkaWF0ZWx5XG4gIEVycm9yID0gXCJlcnJvclwiLCAvLyBFcnJvciBldmVudHMgYXJlIGxpa2VseSB0byBjYXVzZSBwcm9ibGVtc1xuICBXYXJuID0gXCJ3YXJuXCIsIC8vIFdhcm5pbmcgZXZlbnRzIG1pZ2h0IGNhdXNlIHByb2JsZW1zIGluIHRoZSBmdXR1cmUgYW5kIGRlc2VydmUgZXllc1xuICBJbmZvID0gXCJpbmZvXCIsIC8vIFJvdXRpbmUgaW5mb3JtYXRpb24sIHN1Y2ggYXMgb25nb2luZyBzdGF0dXMgb3IgcGVyZm9ybWFuY2VcbiAgSHR0cCA9IFwiaHR0cFwiLCAvLyBIdHRwIGluZm9ybWF0aW9uXG4gIFZlcmJvc2UgPSBcInZlcmJvc2VcIiwgLy8gRGVidWcgb3IgdHJhY2UgaW5mb3JtYXRpb25cbiAgRGVidWcgPSBcImRlYnVnXCIsIC8vIERlYnVnIG9yIHRyYWNlIGluZm9ybWF0aW9uXG4gIFNpbGx5ID0gXCJzaWxseVwiLCAvLyBEZWJ1ZyBvciB0cmFjZSBpbmZvcm1hdGlvblxufVxuXG5leHBvcnQgY29uc3QgTnVtZXJpY0xvZ0xldmVscyA9IHtcbiAgZXJyb3I6IDAsXG4gIHdhcm46IDEsXG4gIGluZm86IDIsXG4gIGh0dHA6IDMsXG4gIHZlcmJvc2U6IDQsXG4gIGRlYnVnOiA1LFxuICBzaWxseTogNixcbn07XG4iXX0=

package/lib/default.cjs

@@ -73,5 +73,4 @@ class DefaultLoggerFactory extends Factory_1.LoggerFactory {
     }
 }
 exports.DefaultLoggerFactory = DefaultLoggerFactory;
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/default.ts"],"names":[],"mappings":"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","file":"default.js","sourcesContent":["import { LoggerFactory } from \"./Factory\";\nimport { LogLevel } from \"./constants\";\nimport { LogData, Logger } from \"./interfaces\";\nimport { toLogLevel } from \"./utils\";\n\nclass DefaultLogger implements Logger {\n  constructor(\n    protected level: LogLevel,\n    protected clazz?: string,\n    protected method?: string\n  ) {}\n\n  log(\n    level: LogLevel,\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    if (toLogLevel(level) < toLogLevel(this.level)) return;\n\n    const { context, app } = data || {};\n\n     \n    const msg = `${profile ? `[${profile}]` : \"\"}${app ? `[${app}]` : \"\"}${context ? `[${context}]` : \"\"}${this.clazz ? `[${this.clazz}]` : \"\"}${this.method ? `[${this.method}]` : \"\"} ${message}`;\n    switch (level) {\n    case LogLevel.Fatal:\n    case LogLevel.Error:\n      return console.error(msg);\n    case LogLevel.Warn:\n      return console.warn(msg);\n    case LogLevel.Info:\n      return console.info(msg);\n    case LogLevel.Http:\n    case LogLevel.Verbose:\n    case LogLevel.Debug:\n    case LogLevel.Silly:\n      return console.debug(msg);\n    default:\n      throw new Error(`Invalid log level: ${level}`);\n    }\n  }\n  silly(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Silly, message, data, profile);\n  }\n\n  verbose(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Verbose, message, data, profile);\n  }\n\n  debug(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Debug, message, data, profile);\n  }\n  info(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Info, message, data, profile);\n  }\n  warn(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Warn, message, data, profile);\n  }\n  error(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Error, message, data, profile);\n  }\n  emerg(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Fatal, message, data, profile);\n  }\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  profile(id: string | number, meta?: Record<string, any> | undefined): void {\n    throw new Error(\"Not implemented\");\n  }\n}\n\nexport class DefaultLoggerFactory extends LoggerFactory {\n  constructor(level: LogLevel) {\n    super(level);\n  }\n\n  forClass(clazz: new (...args: any[]) => any): Logger {\n    return new DefaultLogger(this.level, clazz.name);\n  }\n  forMethod(\n    clazz: new (...args: any[]) => any,\n    method: string | ((...args: any[]) => any)\n  ): Logger {\n    return new DefaultLogger(\n      this.level,\n      clazz.name,\n      typeof method === \"string\" ? method : method.name\n    );\n  }\n\n  get(): Logger {\n    return new DefaultLogger(this.level);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default.js","sourceRoot":"","sources":["../src/default.ts"],"names":[],"mappings":";;;AAAA,uCAA0C;AAC1C,2CAAuC;AAEvC,mCAAqC;AAErC,MAAM,aAAa;IACjB,YACY,KAAe,EACf,KAAc,EACd,MAAe;QAFf,UAAK,GAAL,KAAK,CAAU;QACf,UAAK,GAAL,KAAK,CAAS;QACd,WAAM,GAAN,MAAM,CAAS;IACxB,CAAC;IAEJ,GAAG,CACD,KAAe,EACf,OAAuB,EACvB,IAA0B,EAC1B,OAA4B;QAE5B,IAAI,IAAA,kBAAU,EAAC,KAAK,CAAC,GAAG,IAAA,kBAAU,EAAC,IAAI,CAAC,KAAK,CAAC;YAAE,OAAO;QAEvD,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,IAAI,IAAI,EAAE,CAAC;QAGpC,MAAM,GAAG,GAAG,GAAG,OAAO,CAAC,CAAC,CAAC,IAAI,OAAO,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,IAAI,OAAO,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,OAAO,EAAE,CAAC;QAChM,QAAQ,KAAK,EAAE,CAAC;YAChB,KAAK,oBAAQ,CAAC,KAAK,CAAC;YACpB,KAAK,oBAAQ,CAAC,KAAK;gBACjB,OAAO,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC5B,KAAK,oBAAQ,CAAC,IAAI;gBAChB,OAAO,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC3B,KAAK,oBAAQ,CAAC,IAAI;gBAChB,OAAO,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC3B,KAAK,oBAAQ,CAAC,IAAI,CAAC;YACnB,KAAK,oBAAQ,CAAC,OAAO,CAAC;YACtB,KAAK,oBAAQ,CAAC,KAAK,CAAC;YACpB,KAAK,oBAAQ,CAAC,KAAK;gBACjB,OAAO,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC5B;gBACE,MAAM,IAAI,KAAK,CAAC,sBAAsB,KAAK,EAAE,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;IACD,KAAK,CACH,OAAe,EACf,IAA0B,EAC1B,OAA4B;QAE5B,OAAO,IAAI,CAAC,GAAG,CAAC,oBAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAC1D,CAAC;IAED,OAAO,CACL,OAAe,EACf,IAA0B,EAC1B,OAA4B;QAE5B,OAAO,IAAI,CAAC,GAAG,CAAC,oBAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAC5D,CAAC;IAED,KAAK,CACH,OAAe,EACf,IAA0B,EAC1B,OAA4B;QAE5B,OAAO,IAAI,CAAC,GAAG,CAAC,oBAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAC1D,CAAC;IACD,IAAI,CACF,OAAe,EACf,IAA0B,EAC1B,OAA4B;QAE5B,OAAO,IAAI,CAAC,GAAG,CAAC,oBAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IACzD,CAAC;IACD,IAAI,CACF,OAAuB,EACvB,IAA0B,EAC1B,OAA4B;QAE5B,OAAO,IAAI,CAAC,GAAG,CAAC,oBAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IACzD,CAAC;IACD,KAAK,CACH,OAAuB,EACvB,IAA0B,EAC1B,OAA4B;QAE5B,OAAO,IAAI,CAAC,GAAG,CAAC,oBAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAC1D,CAAC;IACD,KAAK,CACH,OAAuB,EACvB,IAA0B,EAC1B,OAA4B;QAE5B,OAAO,IAAI,CAAC,GAAG,CAAC,oBAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAC1D,CAAC;IACD,6DAA6D;IAC7D,OAAO,CAAC,EAAmB,EAAE,IAAsC;QACjE,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACrC,CAAC;CACF;AAED,MAAa,oBAAqB,SAAQ,uBAAa;IACrD,YAAY,KAAe;QACzB,KAAK,CAAC,KAAK,CAAC,CAAC;IACf,CAAC;IAED,QAAQ,CAAC,KAAkC;QACzC,OAAO,IAAI,aAAa,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;IACnD,CAAC;IACD,SAAS,CACP,KAAkC,EAClC,MAA0C;QAE1C,OAAO,IAAI,aAAa,CACtB,IAAI,CAAC,KAAK,EACV,KAAK,CAAC,IAAI,EACV,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAClD,CAAC;IACJ,CAAC;IAED,GAAG;QACD,OAAO,IAAI,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACvC,CAAC;CACF;AAtBD,oDAsBC","sourcesContent":["import { LoggerFactory } from \"./Factory\";\nimport { LogLevel } from \"./constants\";\nimport { LogData, Logger } from \"./interfaces\";\nimport { toLogLevel } from \"./utils\";\n\nclass DefaultLogger implements Logger {\n  constructor(\n    protected level: LogLevel,\n    protected clazz?: string,\n    protected method?: string\n  ) {}\n\n  log(\n    level: LogLevel,\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    if (toLogLevel(level) < toLogLevel(this.level)) return;\n\n    const { context, app } = data || {};\n\n     \n    const msg = `${profile ? `[${profile}]` : \"\"}${app ? `[${app}]` : \"\"}${context ? `[${context}]` : \"\"}${this.clazz ? `[${this.clazz}]` : \"\"}${this.method ? `[${this.method}]` : \"\"} ${message}`;\n    switch (level) {\n    case LogLevel.Fatal:\n    case LogLevel.Error:\n      return console.error(msg);\n    case LogLevel.Warn:\n      return console.warn(msg);\n    case LogLevel.Info:\n      return console.info(msg);\n    case LogLevel.Http:\n    case LogLevel.Verbose:\n    case LogLevel.Debug:\n    case LogLevel.Silly:\n      return console.debug(msg);\n    default:\n      throw new Error(`Invalid log level: ${level}`);\n    }\n  }\n  silly(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Silly, message, data, profile);\n  }\n\n  verbose(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Verbose, message, data, profile);\n  }\n\n  debug(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Debug, message, data, profile);\n  }\n  info(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Info, message, data, profile);\n  }\n  warn(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Warn, message, data, profile);\n  }\n  error(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Error, message, data, profile);\n  }\n  emerg(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Fatal, message, data, profile);\n  }\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  profile(id: string | number, meta?: Record<string, any> | undefined): void {\n    throw new Error(\"Not implemented\");\n  }\n}\n\nexport class DefaultLoggerFactory extends LoggerFactory {\n  constructor(level: LogLevel) {\n    super(level);\n  }\n\n  forClass(clazz: new (...args: any[]) => any): Logger {\n    return new DefaultLogger(this.level, clazz.name);\n  }\n  forMethod(\n    clazz: new (...args: any[]) => any,\n    method: string | ((...args: any[]) => any)\n  ): Logger {\n    return new DefaultLogger(\n      this.level,\n      clazz.name,\n      typeof method === \"string\" ? method : method.name\n    );\n  }\n\n  get(): Logger {\n    return new DefaultLogger(this.level);\n  }\n}\n"]}

package/lib/esm/Factory.d.ts

@@ -0,0 +1,13 @@
+import { Logger } from "./interfaces";
+import { LogLevel } from "./constants";
+export declare abstract class LoggerFactory {
+    protected level: LogLevel;
+    protected constructor(level: LogLevel);
+    abstract forClass(clazz: {
+        new (...args: any[]): any;
+    }): Logger;
+    abstract forMethod(clazz: {
+        new (...args: any[]): any;
+    }, method: ((...args: any[]) => any) | string): Logger;
+    abstract get(): Logger;
+}

package/lib/esm/Factory.js

@@ -3,5 +3,4 @@ export class LoggerFactory {
         this.level = level;
     }
 }
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9GYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBZ0IsYUFBYTtJQUNqQyxZQUFnQyxLQUFlO1FBQWYsVUFBSyxHQUFMLEtBQUssQ0FBVTtJQUFHLENBQUM7Q0FPcEQiLCJmaWxlIjoiRmFjdG9yeS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IExvZ2dlciB9IGZyb20gXCIuL2ludGVyZmFjZXNcIjtcbmltcG9ydCB7IExvZ0xldmVsIH0gZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBMb2dnZXJGYWN0b3J5IHtcbiAgcHJvdGVjdGVkIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBsZXZlbDogTG9nTGV2ZWwpIHt9XG4gIGFic3RyYWN0IGZvckNsYXNzKGNsYXp6OiB7IG5ldyAoLi4uYXJnczogYW55W10pOiBhbnkgfSk6IExvZ2dlcjtcbiAgYWJzdHJhY3QgZm9yTWV0aG9kKFxuICAgIGNsYXp6OiB7IG5ldyAoLi4uYXJnczogYW55W10pOiBhbnkgfSxcbiAgICBtZXRob2Q6ICgoLi4uYXJnczogYW55W10pID0+IGFueSkgfCBzdHJpbmdcbiAgKTogTG9nZ2VyO1xuICBhYnN0cmFjdCBnZXQoKTogTG9nZ2VyO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRmFjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9GYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBZ0IsYUFBYTtJQUNqQyxZQUFnQyxLQUFlO1FBQWYsVUFBSyxHQUFMLEtBQUssQ0FBVTtJQUFHLENBQUM7Q0FPcEQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBMb2dnZXIgfSBmcm9tIFwiLi9pbnRlcmZhY2VzXCI7XG5pbXBvcnQgeyBMb2dMZXZlbCB9IGZyb20gXCIuL2NvbnN0YW50c1wiO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgTG9nZ2VyRmFjdG9yeSB7XG4gIHByb3RlY3RlZCBjb25zdHJ1Y3Rvcihwcm90ZWN0ZWQgbGV2ZWw6IExvZ0xldmVsKSB7fVxuICBhYnN0cmFjdCBmb3JDbGFzcyhjbGF6ejogeyBuZXcgKC4uLmFyZ3M6IGFueVtdKTogYW55IH0pOiBMb2dnZXI7XG4gIGFic3RyYWN0IGZvck1ldGhvZChcbiAgICBjbGF6ejogeyBuZXcgKC4uLmFyZ3M6IGFueVtdKTogYW55IH0sXG4gICAgbWV0aG9kOiAoKC4uLmFyZ3M6IGFueVtdKSA9PiBhbnkpIHwgc3RyaW5nXG4gICk6IExvZ2dlcjtcbiAgYWJzdHJhY3QgZ2V0KCk6IExvZ2dlcjtcbn1cbiJdfQ==

package/lib/esm/constants.d.ts

@@ -0,0 +1,19 @@
+export declare enum LogLevel {
+    Fatal = "fatal",// A person must take an action immediately
+    Error = "error",// Error events are likely to cause problems
+    Warn = "warn",// Warning events might cause problems in the future and deserve eyes
+    Info = "info",// Routine information, such as ongoing status or performance
+    Http = "http",// Http information
+    Verbose = "verbose",// Debug or trace information
+    Debug = "debug",// Debug or trace information
+    Silly = "silly"
+}
+export declare const NumericLogLevels: {
+    error: number;
+    warn: number;
+    info: number;
+    http: number;
+    verbose: number;
+    debug: number;
+    silly: number;
+};

package/lib/esm/constants.js

@@ -18,5 +18,4 @@ export const NumericLogLevels = {
     debug: 5,
     silly: 6,
 };
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksUUFTWDtBQVRELFdBQVksUUFBUTtJQUNsQiwyQkFBZSxDQUFBO0lBQ2YsMkJBQWUsQ0FBQTtJQUNmLHlCQUFhLENBQUE7SUFDYix5QkFBYSxDQUFBO0lBQ2IseUJBQWEsQ0FBQTtJQUNiLCtCQUFtQixDQUFBO0lBQ25CLDJCQUFlLENBQUE7SUFDZiwyQkFBZSxDQUFBO0FBQ2pCLENBQUMsRUFUVyxRQUFRLEtBQVIsUUFBUSxRQVNuQjtBQUVELE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHO0lBQzlCLEtBQUssRUFBRSxDQUFDO0lBQ1IsSUFBSSxFQUFFLENBQUM7SUFDUCxJQUFJLEVBQUUsQ0FBQztJQUNQLElBQUksRUFBRSxDQUFDO0lBQ1AsT0FBTyxFQUFFLENBQUM7SUFDVixLQUFLLEVBQUUsQ0FBQztJQUNSLEtBQUssRUFBRSxDQUFDO0NBQ1QsQ0FBQyIsImZpbGUiOiJjb25zdGFudHMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBMb2dMZXZlbCB7XG4gIEZhdGFsID0gXCJmYXRhbFwiLCAvLyBBIHBlcnNvbiBtdXN0IHRha2UgYW4gYWN0aW9uIGltbWVkaWF0ZWx5XG4gIEVycm9yID0gXCJlcnJvclwiLCAvLyBFcnJvciBldmVudHMgYXJlIGxpa2VseSB0byBjYXVzZSBwcm9ibGVtc1xuICBXYXJuID0gXCJ3YXJuXCIsIC8vIFdhcm5pbmcgZXZlbnRzIG1pZ2h0IGNhdXNlIHByb2JsZW1zIGluIHRoZSBmdXR1cmUgYW5kIGRlc2VydmUgZXllc1xuICBJbmZvID0gXCJpbmZvXCIsIC8vIFJvdXRpbmUgaW5mb3JtYXRpb24sIHN1Y2ggYXMgb25nb2luZyBzdGF0dXMgb3IgcGVyZm9ybWFuY2VcbiAgSHR0cCA9IFwiaHR0cFwiLCAvLyBIdHRwIGluZm9ybWF0aW9uXG4gIFZlcmJvc2UgPSBcInZlcmJvc2VcIiwgLy8gRGVidWcgb3IgdHJhY2UgaW5mb3JtYXRpb25cbiAgRGVidWcgPSBcImRlYnVnXCIsIC8vIERlYnVnIG9yIHRyYWNlIGluZm9ybWF0aW9uXG4gIFNpbGx5ID0gXCJzaWxseVwiLCAvLyBEZWJ1ZyBvciB0cmFjZSBpbmZvcm1hdGlvblxufVxuXG5leHBvcnQgY29uc3QgTnVtZXJpY0xvZ0xldmVscyA9IHtcbiAgZXJyb3I6IDAsXG4gIHdhcm46IDEsXG4gIGluZm86IDIsXG4gIGh0dHA6IDMsXG4gIHZlcmJvc2U6IDQsXG4gIGRlYnVnOiA1LFxuICBzaWxseTogNixcbn07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxRQVNYO0FBVEQsV0FBWSxRQUFRO0lBQ2xCLDJCQUFlLENBQUE7SUFDZiwyQkFBZSxDQUFBO0lBQ2YseUJBQWEsQ0FBQTtJQUNiLHlCQUFhLENBQUE7SUFDYix5QkFBYSxDQUFBO0lBQ2IsK0JBQW1CLENBQUE7SUFDbkIsMkJBQWUsQ0FBQTtJQUNmLDJCQUFlLENBQUE7QUFDakIsQ0FBQyxFQVRXLFFBQVEsS0FBUixRQUFRLFFBU25CO0FBRUQsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUc7SUFDOUIsS0FBSyxFQUFFLENBQUM7SUFDUixJQUFJLEVBQUUsQ0FBQztJQUNQLElBQUksRUFBRSxDQUFDO0lBQ1AsSUFBSSxFQUFFLENBQUM7SUFDUCxPQUFPLEVBQUUsQ0FBQztJQUNWLEtBQUssRUFBRSxDQUFDO0lBQ1IsS0FBSyxFQUFFLENBQUM7Q0FDVCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gTG9nTGV2ZWwge1xuICBGYXRhbCA9IFwiZmF0YWxcIiwgLy8gQSBwZXJzb24gbXVzdCB0YWtlIGFuIGFjdGlvbiBpbW1lZGlhdGVseVxuICBFcnJvciA9IFwiZXJyb3JcIiwgLy8gRXJyb3IgZXZlbnRzIGFyZSBsaWtlbHkgdG8gY2F1c2UgcHJvYmxlbXNcbiAgV2FybiA9IFwid2FyblwiLCAvLyBXYXJuaW5nIGV2ZW50cyBtaWdodCBjYXVzZSBwcm9ibGVtcyBpbiB0aGUgZnV0dXJlIGFuZCBkZXNlcnZlIGV5ZXNcbiAgSW5mbyA9IFwiaW5mb1wiLCAvLyBSb3V0aW5lIGluZm9ybWF0aW9uLCBzdWNoIGFzIG9uZ29pbmcgc3RhdHVzIG9yIHBlcmZvcm1hbmNlXG4gIEh0dHAgPSBcImh0dHBcIiwgLy8gSHR0cCBpbmZvcm1hdGlvblxuICBWZXJib3NlID0gXCJ2ZXJib3NlXCIsIC8vIERlYnVnIG9yIHRyYWNlIGluZm9ybWF0aW9uXG4gIERlYnVnID0gXCJkZWJ1Z1wiLCAvLyBEZWJ1ZyBvciB0cmFjZSBpbmZvcm1hdGlvblxuICBTaWxseSA9IFwic2lsbHlcIiwgLy8gRGVidWcgb3IgdHJhY2UgaW5mb3JtYXRpb25cbn1cblxuZXhwb3J0IGNvbnN0IE51bWVyaWNMb2dMZXZlbHMgPSB7XG4gIGVycm9yOiAwLFxuICB3YXJuOiAxLFxuICBpbmZvOiAyLFxuICBodHRwOiAzLFxuICB2ZXJib3NlOiA0LFxuICBkZWJ1ZzogNSxcbiAgc2lsbHk6IDYsXG59O1xuIl19

package/lib/esm/default.d.ts

@@ -0,0 +1,9 @@
+import { LoggerFactory } from "./Factory";
+import { LogLevel } from "./constants";
+import { Logger } from "./interfaces";
+export declare class DefaultLoggerFactory extends LoggerFactory {
+    constructor(level: LogLevel);
+    forClass(clazz: new (...args: any[]) => any): Logger;
+    forMethod(clazz: new (...args: any[]) => any, method: string | ((...args: any[]) => any)): Logger;
+    get(): Logger;
+}

package/lib/esm/default.js

@@ -69,5 +69,4 @@ export class DefaultLoggerFactory extends LoggerFactory {
         return new DefaultLogger(this.level);
     }
 }
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/default.ts"],"names":[],"mappings":"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","file":"default.js","sourcesContent":["import { LoggerFactory } from \"./Factory\";\nimport { LogLevel } from \"./constants\";\nimport { LogData, Logger } from \"./interfaces\";\nimport { toLogLevel } from \"./utils\";\n\nclass DefaultLogger implements Logger {\n  constructor(\n    protected level: LogLevel,\n    protected clazz?: string,\n    protected method?: string\n  ) {}\n\n  log(\n    level: LogLevel,\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    if (toLogLevel(level) < toLogLevel(this.level)) return;\n\n    const { context, app } = data || {};\n\n     \n    const msg = `${profile ? `[${profile}]` : \"\"}${app ? `[${app}]` : \"\"}${context ? `[${context}]` : \"\"}${this.clazz ? `[${this.clazz}]` : \"\"}${this.method ? `[${this.method}]` : \"\"} ${message}`;\n    switch (level) {\n    case LogLevel.Fatal:\n    case LogLevel.Error:\n      return console.error(msg);\n    case LogLevel.Warn:\n      return console.warn(msg);\n    case LogLevel.Info:\n      return console.info(msg);\n    case LogLevel.Http:\n    case LogLevel.Verbose:\n    case LogLevel.Debug:\n    case LogLevel.Silly:\n      return console.debug(msg);\n    default:\n      throw new Error(`Invalid log level: ${level}`);\n    }\n  }\n  silly(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Silly, message, data, profile);\n  }\n\n  verbose(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Verbose, message, data, profile);\n  }\n\n  debug(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Debug, message, data, profile);\n  }\n  info(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Info, message, data, profile);\n  }\n  warn(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Warn, message, data, profile);\n  }\n  error(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Error, message, data, profile);\n  }\n  emerg(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Fatal, message, data, profile);\n  }\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  profile(id: string | number, meta?: Record<string, any> | undefined): void {\n    throw new Error(\"Not implemented\");\n  }\n}\n\nexport class DefaultLoggerFactory extends LoggerFactory {\n  constructor(level: LogLevel) {\n    super(level);\n  }\n\n  forClass(clazz: new (...args: any[]) => any): Logger {\n    return new DefaultLogger(this.level, clazz.name);\n  }\n  forMethod(\n    clazz: new (...args: any[]) => any,\n    method: string | ((...args: any[]) => any)\n  ): Logger {\n    return new DefaultLogger(\n      this.level,\n      clazz.name,\n      typeof method === \"string\" ? method : method.name\n    );\n  }\n\n  get(): Logger {\n    return new DefaultLogger(this.level);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default.js","sourceRoot":"","sources":["../../src/default.ts"],"names":[],"mappings":"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","sourcesContent":["import { LoggerFactory } from \"./Factory\";\nimport { LogLevel } from \"./constants\";\nimport { LogData, Logger } from \"./interfaces\";\nimport { toLogLevel } from \"./utils\";\n\nclass DefaultLogger implements Logger {\n  constructor(\n    protected level: LogLevel,\n    protected clazz?: string,\n    protected method?: string\n  ) {}\n\n  log(\n    level: LogLevel,\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    if (toLogLevel(level) < toLogLevel(this.level)) return;\n\n    const { context, app } = data || {};\n\n     \n    const msg = `${profile ? `[${profile}]` : \"\"}${app ? `[${app}]` : \"\"}${context ? `[${context}]` : \"\"}${this.clazz ? `[${this.clazz}]` : \"\"}${this.method ? `[${this.method}]` : \"\"} ${message}`;\n    switch (level) {\n    case LogLevel.Fatal:\n    case LogLevel.Error:\n      return console.error(msg);\n    case LogLevel.Warn:\n      return console.warn(msg);\n    case LogLevel.Info:\n      return console.info(msg);\n    case LogLevel.Http:\n    case LogLevel.Verbose:\n    case LogLevel.Debug:\n    case LogLevel.Silly:\n      return console.debug(msg);\n    default:\n      throw new Error(`Invalid log level: ${level}`);\n    }\n  }\n  silly(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Silly, message, data, profile);\n  }\n\n  verbose(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Verbose, message, data, profile);\n  }\n\n  debug(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Debug, message, data, profile);\n  }\n  info(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Info, message, data, profile);\n  }\n  warn(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Warn, message, data, profile);\n  }\n  error(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Error, message, data, profile);\n  }\n  emerg(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Fatal, message, data, profile);\n  }\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  profile(id: string | number, meta?: Record<string, any> | undefined): void {\n    throw new Error(\"Not implemented\");\n  }\n}\n\nexport class DefaultLoggerFactory extends LoggerFactory {\n  constructor(level: LogLevel) {\n    super(level);\n  }\n\n  forClass(clazz: new (...args: any[]) => any): Logger {\n    return new DefaultLogger(this.level, clazz.name);\n  }\n  forMethod(\n    clazz: new (...args: any[]) => any,\n    method: string | ((...args: any[]) => any)\n  ): Logger {\n    return new DefaultLogger(\n      this.level,\n      clazz.name,\n      typeof method === \"string\" ? method : method.name\n    );\n  }\n\n  get(): Logger {\n    return new DefaultLogger(this.level);\n  }\n}\n"]}

package/{dist/types → lib/esm}/index.d.ts

@@ -21,4 +21,4 @@ export * from "./utils";
  * @const VERSION
  * @memberOf module:ts-workspace
  */
-export declare const VERSION = "0.0.17";
+export declare const VERSION = "0.1.0";

package/lib/esm/index.js

@@ -21,6 +21,5 @@ export * from "./utils";
  * @const VERSION
  * @memberOf module:ts-workspace
  */
-export const VERSION = "0.0.17";
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLFNBQVMsQ0FBQztBQUV4Qjs7OztHQUlHO0FBRUg7Ozs7O0dBS0c7QUFFSDs7Ozs7R0FLRztBQUNILE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxRQUFRLENBQUMiLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlZmF1bHRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0ZhY3RvcnlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ludGVyZmFjZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xvZ2dpbmdcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG5cbi8qKlxuICogQHN1bW1hcnkgTW9kdWxlIHN1bW1hcnlcbiAqIEBkZXNjcmlwdGlvbiBNb2R1bGUgZGVzY3JpcHRpb25cbiAqIEBtb2R1bGUgTG9nZ2luZ1xuICovXG5cbi8qKlxuICogQHN1bW1hcnkgTG9nZ2luZ1xuICogQGRlc2NyaXB0aW9uIE5hbWVzcGFjZSBkZXNjcmlwdGlvblxuICogQG5hbWVzcGFjZSBMb2dnaW5nXG4gKiBAbWVtYmVyT2YgbW9kdWxlOkxvZ2dpbmdcbiAqL1xuXG4vKipcbiAqIEBzdW1tYXJ5IHN0b3JlcyB0aGUgY3VycmVudCBwYWNrYWdlIHZlcnNpb25cbiAqIEBkZXNjcmlwdGlvbiB0aGlzIGlzIGhvdyB5b3Ugc2hvdWxkIGRvY3VtZW50IGEgY29uc3RhbnRcbiAqIEBjb25zdCBWRVJTSU9OXG4gKiBAbWVtYmVyT2YgbW9kdWxlOnRzLXdvcmtzcGFjZVxuICovXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiMC4wLjE3XCI7XG4iXX0=
+export const VERSION = "0.1.0";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxTQUFTLENBQUM7QUFFeEI7Ozs7R0FJRztBQUVIOzs7OztHQUtHO0FBRUg7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZWZhdWx0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9GYWN0b3J5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9pbnRlcmZhY2VzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9sb2dnaW5nXCI7XG5leHBvcnQgKiBmcm9tIFwiLi91dGlsc1wiO1xuXG4vKipcbiAqIEBzdW1tYXJ5IE1vZHVsZSBzdW1tYXJ5XG4gKiBAZGVzY3JpcHRpb24gTW9kdWxlIGRlc2NyaXB0aW9uXG4gKiBAbW9kdWxlIExvZ2dpbmdcbiAqL1xuXG4vKipcbiAqIEBzdW1tYXJ5IExvZ2dpbmdcbiAqIEBkZXNjcmlwdGlvbiBOYW1lc3BhY2UgZGVzY3JpcHRpb25cbiAqIEBuYW1lc3BhY2UgTG9nZ2luZ1xuICogQG1lbWJlck9mIG1vZHVsZTpMb2dnaW5nXG4gKi9cblxuLyoqXG4gKiBAc3VtbWFyeSBzdG9yZXMgdGhlIGN1cnJlbnQgcGFja2FnZSB2ZXJzaW9uXG4gKiBAZGVzY3JpcHRpb24gdGhpcyBpcyBob3cgeW91IHNob3VsZCBkb2N1bWVudCBhIGNvbnN0YW50XG4gKiBAY29uc3QgVkVSU0lPTlxuICogQG1lbWJlck9mIG1vZHVsZTp0cy13b3Jrc3BhY2VcbiAqL1xuZXhwb3J0IGNvbnN0IFZFUlNJT04gPSBcIiMjVkVSU0lPTiMjXCI7XG4iXX0=

package/lib/esm/interfaces.js

@@ -1,3 +1,2 @@
 export {};
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IExvZ0xldmVsIH0gZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTG9nRGF0YSB7XG4gIG9yZ2FuaXphdGlvbj86IHN0cmluZzsgLy8gT3JnYW5pemF0aW9uIG9yIHByb2plY3QgbmFtZVxuICBjb250ZXh0Pzogc3RyaW5nOyAvLyBCb3VuZGVkIENvbnRleHQgbmFtZVxuICBhcHA/OiBzdHJpbmc7IC8vIEFwcGxpY2F0aW9uIG9yIE1pY3Jvc2VydmljZSBuYW1lXG4gIHNvdXJjZUNsYXNzPzogc3RyaW5nOyAvLyBDbGFzc25hbWUgb2YgdGhlIHNvdXJjZVxuICBjb3JyZWxhdGlvbklkPzogc3RyaW5nOyAvLyBDb3JyZWxhdGlvbiBJRFxuICBlcnJvcj86IEVycm9yOyAvLyBFcnJvciBvYmplY3RcbiAgcHJvcHM/OiBSZWNvcmQ8c3RyaW5nLCBhbnk+OyAvLyBBZGRpdGlvbmFsIGN1c3RvbSBwcm9wZXJ0aWVzXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgTG9nZ2VyIHtcbiAgbG9nKFxuICAgIGxldmVsOiBMb2dMZXZlbCxcbiAgICBtZXNzYWdlOiBzdHJpbmcgfCBFcnJvcixcbiAgICBkYXRhPzogTG9nRGF0YSxcbiAgICBwcm9maWxlPzogc3RyaW5nXG4gICk6IHZvaWQ7XG4gIHNpbGx5KG1lc3NhZ2U6IHN0cmluZywgZGF0YT86IExvZ0RhdGEsIHByb2ZpbGU/OiBzdHJpbmcpOiB2b2lkO1xuICB2ZXJib3NlKG1lc3NhZ2U6IHN0cmluZywgZGF0YT86IExvZ0RhdGEsIHByb2ZpbGU/OiBzdHJpbmcpOiB2b2lkO1xuICBkZWJ1ZyhtZXNzYWdlOiBzdHJpbmcsIGRhdGE/OiBMb2dEYXRhLCBwcm9maWxlPzogc3RyaW5nKTogdm9pZDtcbiAgaW5mbyhtZXNzYWdlOiBzdHJpbmcsIGRhdGE/OiBMb2dEYXRhLCBwcm9maWxlPzogc3RyaW5nKTogdm9pZDtcbiAgd2FybihtZXNzYWdlOiBzdHJpbmcgfCBFcnJvciwgZGF0YT86IExvZ0RhdGEsIHByb2ZpbGU/OiBzdHJpbmcpOiB2b2lkO1xuICBlcnJvcihtZXNzYWdlOiBzdHJpbmcgfCBFcnJvciwgZGF0YT86IExvZ0RhdGEsIHByb2ZpbGU/OiBzdHJpbmcpOiB2b2lkO1xuICBlbWVyZyhtZXNzYWdlOiBzdHJpbmcgfCBFcnJvciwgZGF0YT86IExvZ0RhdGEsIHByb2ZpbGU/OiBzdHJpbmcpOiB2b2lkO1xuICBwcm9maWxlKGlkOiBzdHJpbmcgfCBudW1iZXIsIG1ldGE/OiBSZWNvcmQ8c3RyaW5nLCBhbnk+KTogdm9pZDtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBMb2dMZXZlbCB9IGZyb20gXCIuL2NvbnN0YW50c1wiO1xuXG5leHBvcnQgaW50ZXJmYWNlIExvZ0RhdGEge1xuICBvcmdhbml6YXRpb24/OiBzdHJpbmc7IC8vIE9yZ2FuaXphdGlvbiBvciBwcm9qZWN0IG5hbWVcbiAgY29udGV4dD86IHN0cmluZzsgLy8gQm91bmRlZCBDb250ZXh0IG5hbWVcbiAgYXBwPzogc3RyaW5nOyAvLyBBcHBsaWNhdGlvbiBvciBNaWNyb3NlcnZpY2UgbmFtZVxuICBzb3VyY2VDbGFzcz86IHN0cmluZzsgLy8gQ2xhc3NuYW1lIG9mIHRoZSBzb3VyY2VcbiAgY29ycmVsYXRpb25JZD86IHN0cmluZzsgLy8gQ29ycmVsYXRpb24gSURcbiAgZXJyb3I/OiBFcnJvcjsgLy8gRXJyb3Igb2JqZWN0XG4gIHByb3BzPzogUmVjb3JkPHN0cmluZywgYW55PjsgLy8gQWRkaXRpb25hbCBjdXN0b20gcHJvcGVydGllc1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIExvZ2dlciB7XG4gIGxvZyhcbiAgICBsZXZlbDogTG9nTGV2ZWwsXG4gICAgbWVzc2FnZTogc3RyaW5nIHwgRXJyb3IsXG4gICAgZGF0YT86IExvZ0RhdGEsXG4gICAgcHJvZmlsZT86IHN0cmluZ1xuICApOiB2b2lkO1xuICBzaWxseShtZXNzYWdlOiBzdHJpbmcsIGRhdGE/OiBMb2dEYXRhLCBwcm9maWxlPzogc3RyaW5nKTogdm9pZDtcbiAgdmVyYm9zZShtZXNzYWdlOiBzdHJpbmcsIGRhdGE/OiBMb2dEYXRhLCBwcm9maWxlPzogc3RyaW5nKTogdm9pZDtcbiAgZGVidWcobWVzc2FnZTogc3RyaW5nLCBkYXRhPzogTG9nRGF0YSwgcHJvZmlsZT86IHN0cmluZyk6IHZvaWQ7XG4gIGluZm8obWVzc2FnZTogc3RyaW5nLCBkYXRhPzogTG9nRGF0YSwgcHJvZmlsZT86IHN0cmluZyk6IHZvaWQ7XG4gIHdhcm4obWVzc2FnZTogc3RyaW5nIHwgRXJyb3IsIGRhdGE/OiBMb2dEYXRhLCBwcm9maWxlPzogc3RyaW5nKTogdm9pZDtcbiAgZXJyb3IobWVzc2FnZTogc3RyaW5nIHwgRXJyb3IsIGRhdGE/OiBMb2dEYXRhLCBwcm9maWxlPzogc3RyaW5nKTogdm9pZDtcbiAgZW1lcmcobWVzc2FnZTogc3RyaW5nIHwgRXJyb3IsIGRhdGE/OiBMb2dEYXRhLCBwcm9maWxlPzogc3RyaW5nKTogdm9pZDtcbiAgcHJvZmlsZShpZDogc3RyaW5nIHwgbnVtYmVyLCBtZXRhPzogUmVjb3JkPHN0cmluZywgYW55Pik6IHZvaWQ7XG59XG4iXX0=

package/lib/esm/logging.js

@@ -41,5 +41,4 @@ export class Logging {
         return this.global;
     }
 }
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/utils.js

@@ -5,5 +5,4 @@ export function toLogLevel(level) {
     }
     throw new Error(`Invalid level: ${level.toString()}`);
 }
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQVksZ0JBQWdCLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFekQsTUFBTSxVQUFVLFVBQVUsQ0FBQyxLQUFlO0lBQ3hDLElBQUksS0FBSyxDQUFDLFFBQVEsRUFBRSxJQUFJLGdCQUFnQixFQUFFLENBQUM7UUFDekMsT0FBUSxnQkFBd0MsQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQztJQUNyRSxDQUFDO0lBQ0QsTUFBTSxJQUFJLEtBQUssQ0FBQyxrQkFBa0IsS0FBSyxDQUFDLFFBQVEsRUFBRSxFQUFFLENBQUMsQ0FBQztBQUN4RCxDQUFDIiwiZmlsZSI6InV0aWxzLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTG9nTGV2ZWwsIE51bWVyaWNMb2dMZXZlbHMgfSBmcm9tIFwiLi9jb25zdGFudHNcIjtcblxuZXhwb3J0IGZ1bmN0aW9uIHRvTG9nTGV2ZWwobGV2ZWw6IExvZ0xldmVsKTogbnVtYmVyIHtcbiAgaWYgKGxldmVsLnRvU3RyaW5nKCkgaW4gTnVtZXJpY0xvZ0xldmVscykge1xuICAgIHJldHVybiAoTnVtZXJpY0xvZ0xldmVscyBhcyBSZWNvcmQ8c3RyaW5nLCBhbnk+KVtsZXZlbC50b1N0cmluZygpXTtcbiAgfVxuICB0aHJvdyBuZXcgRXJyb3IoYEludmFsaWQgbGV2ZWw6ICR7bGV2ZWwudG9TdHJpbmcoKX1gKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFZLGdCQUFnQixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRXpELE1BQU0sVUFBVSxVQUFVLENBQUMsS0FBZTtJQUN4QyxJQUFJLEtBQUssQ0FBQyxRQUFRLEVBQUUsSUFBSSxnQkFBZ0IsRUFBRSxDQUFDO1FBQ3pDLE9BQVEsZ0JBQXdDLENBQUMsS0FBSyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDckUsQ0FBQztJQUNELE1BQU0sSUFBSSxLQUFLLENBQUMsa0JBQWtCLEtBQUssQ0FBQyxRQUFRLEVBQUUsRUFBRSxDQUFDLENBQUM7QUFDeEQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IExvZ0xldmVsLCBOdW1lcmljTG9nTGV2ZWxzIH0gZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiB0b0xvZ0xldmVsKGxldmVsOiBMb2dMZXZlbCk6IG51bWJlciB7XG4gIGlmIChsZXZlbC50b1N0cmluZygpIGluIE51bWVyaWNMb2dMZXZlbHMpIHtcbiAgICByZXR1cm4gKE51bWVyaWNMb2dMZXZlbHMgYXMgUmVjb3JkPHN0cmluZywgYW55PilbbGV2ZWwudG9TdHJpbmcoKV07XG4gIH1cbiAgdGhyb3cgbmV3IEVycm9yKGBJbnZhbGlkIGxldmVsOiAke2xldmVsLnRvU3RyaW5nKCl9YCk7XG59XG4iXX0=

package/lib/esm/winston.js

@@ -35,5 +35,4 @@ export class WinstonLoggerFactory extends LoggerFactory {
         return this.generate(this.level);
     }
 }
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.cjs

@@ -38,6 +38,5 @@ __exportStar(require("./utils.cjs"), exports);
  * @const VERSION
  * @memberOf module:ts-workspace
  */
-exports.VERSION = "0.0.17";
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDhDQUE0QjtBQUM1Qiw0Q0FBMEI7QUFDMUIsNENBQTBCO0FBQzFCLCtDQUE2QjtBQUM3Qiw0Q0FBMEI7QUFDMUIsMENBQXdCO0FBRXhCOzs7O0dBSUc7QUFFSDs7Ozs7R0FLRztBQUVIOzs7OztHQUtHO0FBQ1UsUUFBQSxPQUFPLEdBQUcsUUFBUSxDQUFDIiwiZmlsZSI6ImluZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZWZhdWx0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9GYWN0b3J5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9pbnRlcmZhY2VzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9sb2dnaW5nXCI7XG5leHBvcnQgKiBmcm9tIFwiLi91dGlsc1wiO1xuXG4vKipcbiAqIEBzdW1tYXJ5IE1vZHVsZSBzdW1tYXJ5XG4gKiBAZGVzY3JpcHRpb24gTW9kdWxlIGRlc2NyaXB0aW9uXG4gKiBAbW9kdWxlIExvZ2dpbmdcbiAqL1xuXG4vKipcbiAqIEBzdW1tYXJ5IExvZ2dpbmdcbiAqIEBkZXNjcmlwdGlvbiBOYW1lc3BhY2UgZGVzY3JpcHRpb25cbiAqIEBuYW1lc3BhY2UgTG9nZ2luZ1xuICogQG1lbWJlck9mIG1vZHVsZTpMb2dnaW5nXG4gKi9cblxuLyoqXG4gKiBAc3VtbWFyeSBzdG9yZXMgdGhlIGN1cnJlbnQgcGFja2FnZSB2ZXJzaW9uXG4gKiBAZGVzY3JpcHRpb24gdGhpcyBpcyBob3cgeW91IHNob3VsZCBkb2N1bWVudCBhIGNvbnN0YW50XG4gKiBAY29uc3QgVkVSU0lPTlxuICogQG1lbWJlck9mIG1vZHVsZTp0cy13b3Jrc3BhY2VcbiAqL1xuZXhwb3J0IGNvbnN0IFZFUlNJT04gPSBcIjAuMC4xN1wiO1xuIl19
+exports.VERSION = "0.1.0";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSw4Q0FBNEI7QUFDNUIsNENBQTBCO0FBQzFCLDRDQUEwQjtBQUMxQiwrQ0FBNkI7QUFDN0IsNENBQTBCO0FBQzFCLDBDQUF3QjtBQUV4Qjs7OztHQUlHO0FBRUg7Ozs7O0dBS0c7QUFFSDs7Ozs7R0FLRztBQUNVLFFBQUEsT0FBTyxHQUFHLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVmYXVsdFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vRmFjdG9yeVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vaW50ZXJmYWNlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vbG9nZ2luZ1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdXRpbHNcIjtcblxuLyoqXG4gKiBAc3VtbWFyeSBNb2R1bGUgc3VtbWFyeVxuICogQGRlc2NyaXB0aW9uIE1vZHVsZSBkZXNjcmlwdGlvblxuICogQG1vZHVsZSBMb2dnaW5nXG4gKi9cblxuLyoqXG4gKiBAc3VtbWFyeSBMb2dnaW5nXG4gKiBAZGVzY3JpcHRpb24gTmFtZXNwYWNlIGRlc2NyaXB0aW9uXG4gKiBAbmFtZXNwYWNlIExvZ2dpbmdcbiAqIEBtZW1iZXJPZiBtb2R1bGU6TG9nZ2luZ1xuICovXG5cbi8qKlxuICogQHN1bW1hcnkgc3RvcmVzIHRoZSBjdXJyZW50IHBhY2thZ2UgdmVyc2lvblxuICogQGRlc2NyaXB0aW9uIHRoaXMgaXMgaG93IHlvdSBzaG91bGQgZG9jdW1lbnQgYSBjb25zdGFudFxuICogQGNvbnN0IFZFUlNJT05cbiAqIEBtZW1iZXJPZiBtb2R1bGU6dHMtd29ya3NwYWNlXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gXCIjI1ZFUlNJT04jI1wiO1xuIl19

package/lib/index.d.ts

@@ -0,0 +1,24 @@
+export * from "./constants";
+export * from "./default";
+export * from "./Factory";
+export * from "./interfaces";
+export * from "./logging";
+export * from "./utils";
+/**
+ * @summary Module summary
+ * @description Module description
+ * @module Logging
+ */
+/**
+ * @summary Logging
+ * @description Namespace description
+ * @namespace Logging
+ * @memberOf module:Logging
+ */
+/**
+ * @summary stores the current package version
+ * @description this is how you should document a constant
+ * @const VERSION
+ * @memberOf module:ts-workspace
+ */
+export declare const VERSION = "0.1.0";

package/lib/interfaces.cjs

@@ -1,4 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IExvZ0xldmVsIH0gZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTG9nRGF0YSB7XG4gIG9yZ2FuaXphdGlvbj86IHN0cmluZzsgLy8gT3JnYW5pemF0aW9uIG9yIHByb2plY3QgbmFtZVxuICBjb250ZXh0Pzogc3RyaW5nOyAvLyBCb3VuZGVkIENvbnRleHQgbmFtZVxuICBhcHA/OiBzdHJpbmc7IC8vIEFwcGxpY2F0aW9uIG9yIE1pY3Jvc2VydmljZSBuYW1lXG4gIHNvdXJjZUNsYXNzPzogc3RyaW5nOyAvLyBDbGFzc25hbWUgb2YgdGhlIHNvdXJjZVxuICBjb3JyZWxhdGlvbklkPzogc3RyaW5nOyAvLyBDb3JyZWxhdGlvbiBJRFxuICBlcnJvcj86IEVycm9yOyAvLyBFcnJvciBvYmplY3RcbiAgcHJvcHM/OiBSZWNvcmQ8c3RyaW5nLCBhbnk+OyAvLyBBZGRpdGlvbmFsIGN1c3RvbSBwcm9wZXJ0aWVzXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgTG9nZ2VyIHtcbiAgbG9nKFxuICAgIGxldmVsOiBMb2dMZXZlbCxcbiAgICBtZXNzYWdlOiBzdHJpbmcgfCBFcnJvcixcbiAgICBkYXRhPzogTG9nRGF0YSxcbiAgICBwcm9maWxlPzogc3RyaW5nXG4gICk6IHZvaWQ7XG4gIHNpbGx5KG1lc3NhZ2U6IHN0cmluZywgZGF0YT86IExvZ0RhdGEsIHByb2ZpbGU/OiBzdHJpbmcpOiB2b2lkO1xuICB2ZXJib3NlKG1lc3NhZ2U6IHN0cmluZywgZGF0YT86IExvZ0RhdGEsIHByb2ZpbGU/OiBzdHJpbmcpOiB2b2lkO1xuICBkZWJ1ZyhtZXNzYWdlOiBzdHJpbmcsIGRhdGE/OiBMb2dEYXRhLCBwcm9maWxlPzogc3RyaW5nKTogdm9pZDtcbiAgaW5mbyhtZXNzYWdlOiBzdHJpbmcsIGRhdGE/OiBMb2dEYXRhLCBwcm9maWxlPzogc3RyaW5nKTogdm9pZDtcbiAgd2FybihtZXNzYWdlOiBzdHJpbmcgfCBFcnJvciwgZGF0YT86IExvZ0RhdGEsIHByb2ZpbGU/OiBzdHJpbmcpOiB2b2lkO1xuICBlcnJvcihtZXNzYWdlOiBzdHJpbmcgfCBFcnJvciwgZGF0YT86IExvZ0RhdGEsIHByb2ZpbGU/OiBzdHJpbmcpOiB2b2lkO1xuICBlbWVyZyhtZXNzYWdlOiBzdHJpbmcgfCBFcnJvciwgZGF0YT86IExvZ0RhdGEsIHByb2ZpbGU/OiBzdHJpbmcpOiB2b2lkO1xuICBwcm9maWxlKGlkOiBzdHJpbmcgfCBudW1iZXIsIG1ldGE/OiBSZWNvcmQ8c3RyaW5nLCBhbnk+KTogdm9pZDtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBMb2dMZXZlbCB9IGZyb20gXCIuL2NvbnN0YW50c1wiO1xuXG5leHBvcnQgaW50ZXJmYWNlIExvZ0RhdGEge1xuICBvcmdhbml6YXRpb24/OiBzdHJpbmc7IC8vIE9yZ2FuaXphdGlvbiBvciBwcm9qZWN0IG5hbWVcbiAgY29udGV4dD86IHN0cmluZzsgLy8gQm91bmRlZCBDb250ZXh0IG5hbWVcbiAgYXBwPzogc3RyaW5nOyAvLyBBcHBsaWNhdGlvbiBvciBNaWNyb3NlcnZpY2UgbmFtZVxuICBzb3VyY2VDbGFzcz86IHN0cmluZzsgLy8gQ2xhc3NuYW1lIG9mIHRoZSBzb3VyY2VcbiAgY29ycmVsYXRpb25JZD86IHN0cmluZzsgLy8gQ29ycmVsYXRpb24gSURcbiAgZXJyb3I/OiBFcnJvcjsgLy8gRXJyb3Igb2JqZWN0XG4gIHByb3BzPzogUmVjb3JkPHN0cmluZywgYW55PjsgLy8gQWRkaXRpb25hbCBjdXN0b20gcHJvcGVydGllc1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIExvZ2dlciB7XG4gIGxvZyhcbiAgICBsZXZlbDogTG9nTGV2ZWwsXG4gICAgbWVzc2FnZTogc3RyaW5nIHwgRXJyb3IsXG4gICAgZGF0YT86IExvZ0RhdGEsXG4gICAgcHJvZmlsZT86IHN0cmluZ1xuICApOiB2b2lkO1xuICBzaWxseShtZXNzYWdlOiBzdHJpbmcsIGRhdGE/OiBMb2dEYXRhLCBwcm9maWxlPzogc3RyaW5nKTogdm9pZDtcbiAgdmVyYm9zZShtZXNzYWdlOiBzdHJpbmcsIGRhdGE/OiBMb2dEYXRhLCBwcm9maWxlPzogc3RyaW5nKTogdm9pZDtcbiAgZGVidWcobWVzc2FnZTogc3RyaW5nLCBkYXRhPzogTG9nRGF0YSwgcHJvZmlsZT86IHN0cmluZyk6IHZvaWQ7XG4gIGluZm8obWVzc2FnZTogc3RyaW5nLCBkYXRhPzogTG9nRGF0YSwgcHJvZmlsZT86IHN0cmluZyk6IHZvaWQ7XG4gIHdhcm4obWVzc2FnZTogc3RyaW5nIHwgRXJyb3IsIGRhdGE/OiBMb2dEYXRhLCBwcm9maWxlPzogc3RyaW5nKTogdm9pZDtcbiAgZXJyb3IobWVzc2FnZTogc3RyaW5nIHwgRXJyb3IsIGRhdGE/OiBMb2dEYXRhLCBwcm9maWxlPzogc3RyaW5nKTogdm9pZDtcbiAgZW1lcmcobWVzc2FnZTogc3RyaW5nIHwgRXJyb3IsIGRhdGE/OiBMb2dEYXRhLCBwcm9maWxlPzogc3RyaW5nKTogdm9pZDtcbiAgcHJvZmlsZShpZDogc3RyaW5nIHwgbnVtYmVyLCBtZXRhPzogUmVjb3JkPHN0cmluZywgYW55Pik6IHZvaWQ7XG59XG4iXX0=

package/lib/interfaces.d.ts

@@ -0,0 +1,21 @@
+import { LogLevel } from "./constants";
+export interface LogData {
+    organization?: string;
+    context?: string;
+    app?: string;
+    sourceClass?: string;
+    correlationId?: string;
+    error?: Error;
+    props?: Record<string, any>;
+}
+export interface Logger {
+    log(level: LogLevel, message: string | Error, data?: LogData, profile?: string): void;
+    silly(message: string, data?: LogData, profile?: string): void;
+    verbose(message: string, data?: LogData, profile?: string): void;
+    debug(message: string, data?: LogData, profile?: string): void;
+    info(message: string, data?: LogData, profile?: string): void;
+    warn(message: string | Error, data?: LogData, profile?: string): void;
+    error(message: string | Error, data?: LogData, profile?: string): void;
+    emerg(message: string | Error, data?: LogData, profile?: string): void;
+    profile(id: string | number, meta?: Record<string, any>): void;
+}

package/lib/logging.cjs

@@ -45,5 +45,4 @@ class Logging {
     }
 }
 exports.Logging = Logging;
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/logging.d.ts

@@ -0,0 +1,25 @@
+import { Logger } from "./interfaces";
+import { LoggerFactory } from "./Factory";
+import { LogLevel } from "./constants";
+export declare class Logging {
+    private static _level;
+    private static _factory;
+    private static _instance;
+    private static cacheByClass;
+    private static cacheByClassMethod;
+    private static global;
+    private constructor();
+    static get level(): LogLevel;
+    static set level(level: LogLevel);
+    protected static get instance(): LoggerFactory;
+    static set factory(factory: {
+        new (level: LogLevel): LoggerFactory;
+    });
+    static forClass(clazz: {
+        new (...args: any[]): any;
+    }): Logger;
+    static forMethod(clazz: {
+        new (...args: any[]): any;
+    }, method: ((...args: any[]) => any) | string): Logger;
+    static get(): Logger;
+}

package/lib/utils.cjs

@@ -8,5 +8,4 @@ function toLogLevel(level) {
     }
     throw new Error(`Invalid level: ${level.toString()}`);
 }
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUVBLGdDQUtDO0FBUEQsMkNBQXlEO0FBRXpELFNBQWdCLFVBQVUsQ0FBQyxLQUFlO0lBQ3hDLElBQUksS0FBSyxDQUFDLFFBQVEsRUFBRSxJQUFJLDRCQUFnQixFQUFFLENBQUM7UUFDekMsT0FBUSw0QkFBd0MsQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQztJQUNyRSxDQUFDO0lBQ0QsTUFBTSxJQUFJLEtBQUssQ0FBQyxrQkFBa0IsS0FBSyxDQUFDLFFBQVEsRUFBRSxFQUFFLENBQUMsQ0FBQztBQUN4RCxDQUFDIiwiZmlsZSI6InV0aWxzLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTG9nTGV2ZWwsIE51bWVyaWNMb2dMZXZlbHMgfSBmcm9tIFwiLi9jb25zdGFudHNcIjtcblxuZXhwb3J0IGZ1bmN0aW9uIHRvTG9nTGV2ZWwobGV2ZWw6IExvZ0xldmVsKTogbnVtYmVyIHtcbiAgaWYgKGxldmVsLnRvU3RyaW5nKCkgaW4gTnVtZXJpY0xvZ0xldmVscykge1xuICAgIHJldHVybiAoTnVtZXJpY0xvZ0xldmVscyBhcyBSZWNvcmQ8c3RyaW5nLCBhbnk+KVtsZXZlbC50b1N0cmluZygpXTtcbiAgfVxuICB0aHJvdyBuZXcgRXJyb3IoYEludmFsaWQgbGV2ZWw6ICR7bGV2ZWwudG9TdHJpbmcoKX1gKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFFQSxnQ0FLQztBQVBELDJDQUF5RDtBQUV6RCxTQUFnQixVQUFVLENBQUMsS0FBZTtJQUN4QyxJQUFJLEtBQUssQ0FBQyxRQUFRLEVBQUUsSUFBSSw0QkFBZ0IsRUFBRSxDQUFDO1FBQ3pDLE9BQVEsNEJBQXdDLENBQUMsS0FBSyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDckUsQ0FBQztJQUNELE1BQU0sSUFBSSxLQUFLLENBQUMsa0JBQWtCLEtBQUssQ0FBQyxRQUFRLEVBQUUsRUFBRSxDQUFDLENBQUM7QUFDeEQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IExvZ0xldmVsLCBOdW1lcmljTG9nTGV2ZWxzIH0gZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiB0b0xvZ0xldmVsKGxldmVsOiBMb2dMZXZlbCk6IG51bWJlciB7XG4gIGlmIChsZXZlbC50b1N0cmluZygpIGluIE51bWVyaWNMb2dMZXZlbHMpIHtcbiAgICByZXR1cm4gKE51bWVyaWNMb2dMZXZlbHMgYXMgUmVjb3JkPHN0cmluZywgYW55PilbbGV2ZWwudG9TdHJpbmcoKV07XG4gIH1cbiAgdGhyb3cgbmV3IEVycm9yKGBJbnZhbGlkIGxldmVsOiAke2xldmVsLnRvU3RyaW5nKCl9YCk7XG59XG4iXX0=

package/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { LogLevel } from "./constants";
+export declare function toLogLevel(level: LogLevel): number;

package/lib/winston.cjs

@@ -1,8 +1,41 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WinstonLoggerFactory = void 0;
 const Factory_1 = require("./Factory.cjs");
-const winston = require("winston");
+const winston = __importStar(require("winston"));
 class WinstonLoggerFactory extends Factory_1.LoggerFactory {
     constructor(level) {
         super(level);
@@ -39,5 +72,4 @@ class WinstonLoggerFactory extends Factory_1.LoggerFactory {
     }
 }
 exports.WinstonLoggerFactory = WinstonLoggerFactory;
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2luc3Rvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy93aW5zdG9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHVDQUEwQztBQUUxQyxpREFBbUM7QUFJbkMsTUFBYSxvQkFBcUIsU0FBUSx1QkFBYTtJQUNyRCxZQUFZLEtBQWU7UUFDekIsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ2YsQ0FBQztJQUVTLFFBQVEsQ0FBQyxHQUFhLEVBQUUsS0FBYyxFQUFFLE1BQWU7UUFDL0QsTUFBTSxNQUFNLEdBQWtCO1lBQzVCLEtBQUssRUFBRSxHQUFHO1lBQ1YsTUFBTSxFQUFFLE9BQU8sQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFO1lBQzdCLFVBQVUsRUFBRTtnQkFDVixJQUFJLE9BQU8sQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDO29CQUM3QixNQUFNLEVBQUUsT0FBTyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQzVCLE9BQU8sQ0FBQyxNQUFNLENBQUMsUUFBUSxFQUFFLEVBQ3pCLE9BQU8sQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFLEVBQ3RCLE9BQU8sQ0FBQyxNQUFNLENBQUMsTUFBTSxFQUFFLENBQ3hCO2lCQUNGLENBQUM7YUFDSDtTQUNGLENBQUM7UUFDRixJQUFJLElBQTZCLENBQUM7UUFDbEMsSUFBSSxLQUFLLElBQUksTUFBTSxFQUFFLENBQUM7WUFDcEIsSUFBSSxHQUFHLEVBQUUsQ0FBQztZQUNWLElBQUksS0FBSztnQkFBRSxJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsS0FBSyxDQUFDO1lBQ25DLElBQUksTUFBTTtnQkFBRSxJQUFJLENBQUMsUUFBUSxDQUFDLEdBQUcsTUFBTSxDQUFDO1lBQ3BDLE1BQU0sQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDO1FBQzVCLENBQUM7UUFDRCxPQUFPLE9BQU8sQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDdEMsQ0FBQztJQUVELFFBQVEsQ0FBQyxLQUFvQztRQUMzQyxPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRSxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDL0MsQ0FBQztJQUNELFNBQVMsQ0FDUCxLQUFvQyxFQUNwQyxNQUEwQztRQUUxQyxPQUFPLElBQUksQ0FBQyxRQUFRLENBQ2xCLElBQUksQ0FBQyxLQUFLLEVBQ1YsS0FBSyxDQUFDLElBQUksRUFDVixPQUFPLE1BQU0sS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLElBQUksQ0FDbEQsQ0FBQztJQUNKLENBQUM7SUFDRCxHQUFHO1FBQ0QsT0FBTyxJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNuQyxDQUFDO0NBQ0Y7QUE3Q0Qsb0RBNkNDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTG9nZ2VyRmFjdG9yeSB9IGZyb20gXCIuL0ZhY3RvcnlcIjtcbmltcG9ydCB7IExvZ2dlciB9IGZyb20gXCIuL2ludGVyZmFjZXNcIjtcbmltcG9ydCAqIGFzIHdpbnN0b24gZnJvbSBcIndpbnN0b25cIjtcbmltcG9ydCB7IExvZ0xldmVsIH0gZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5pbXBvcnQgeyBMb2dnZXJPcHRpb25zIH0gZnJvbSBcIndpbnN0b25cIjtcblxuZXhwb3J0IGNsYXNzIFdpbnN0b25Mb2dnZXJGYWN0b3J5IGV4dGVuZHMgTG9nZ2VyRmFjdG9yeSB7XG4gIGNvbnN0cnVjdG9yKGxldmVsOiBMb2dMZXZlbCkge1xuICAgIHN1cGVyKGxldmVsKTtcbiAgfVxuXG4gIHByb3RlY3RlZCBnZW5lcmF0ZShsdmw6IExvZ0xldmVsLCBjbGF6ej86IHN0cmluZywgbWV0aG9kPzogc3RyaW5nKSB7XG4gICAgY29uc3QgY29uZmlnOiBMb2dnZXJPcHRpb25zID0ge1xuICAgICAgbGV2ZWw6IGx2bCxcbiAgICAgIGZvcm1hdDogd2luc3Rvbi5mb3JtYXQuanNvbigpLFxuICAgICAgdHJhbnNwb3J0czogW1xuICAgICAgICBuZXcgd2luc3Rvbi50cmFuc3BvcnRzLkNvbnNvbGUoe1xuICAgICAgICAgIGZvcm1hdDogd2luc3Rvbi5mb3JtYXQuY29tYmluZShcbiAgICAgICAgICAgIHdpbnN0b24uZm9ybWF0LmNvbG9yaXplKCksXG4gICAgICAgICAgICB3aW5zdG9uLmZvcm1hdC5zcGxhdCgpLFxuICAgICAgICAgICAgd2luc3Rvbi5mb3JtYXQuc2ltcGxlKClcbiAgICAgICAgICApLFxuICAgICAgICB9KSxcbiAgICAgIF0sXG4gICAgfTtcbiAgICBsZXQgbWV0YTogUmVjb3JkPHN0cmluZywgdW5rbm93bj47XG4gICAgaWYgKGNsYXp6IHx8IG1ldGhvZCkge1xuICAgICAgbWV0YSA9IHt9O1xuICAgICAgaWYgKGNsYXp6KSBtZXRhW1wic2VydmljZVwiXSA9IGNsYXp6O1xuICAgICAgaWYgKG1ldGhvZCkgbWV0YVtcIm1ldGhvZFwiXSA9IG1ldGhvZDtcbiAgICAgIGNvbmZpZy5kZWZhdWx0TWV0YSA9IG1ldGE7XG4gICAgfVxuICAgIHJldHVybiB3aW5zdG9uLmNyZWF0ZUxvZ2dlcihjb25maWcpO1xuICB9XG5cbiAgZm9yQ2xhc3MoY2xheno6IHsgbmV3ICguLi5hcmdzOiBhbnlbXSk6IGFueSB9KTogTG9nZ2VyIHtcbiAgICByZXR1cm4gdGhpcy5nZW5lcmF0ZSh0aGlzLmxldmVsLCBjbGF6ei5uYW1lKTtcbiAgfVxuICBmb3JNZXRob2QoXG4gICAgY2xheno6IHsgbmV3ICguLi5hcmdzOiBhbnlbXSk6IGFueSB9LFxuICAgIG1ldGhvZDogKCguLi5hcmdzOiBhbnlbXSkgPT4gYW55KSB8IHN0cmluZ1xuICApOiBMb2dnZXIge1xuICAgIHJldHVybiB0aGlzLmdlbmVyYXRlKFxuICAgICAgdGhpcy5sZXZlbCxcbiAgICAgIGNsYXp6Lm5hbWUsXG4gICAgICB0eXBlb2YgbWV0aG9kID09PSBcInN0cmluZ1wiID8gbWV0aG9kIDogbWV0aG9kLm5hbWVcbiAgICApO1xuICB9XG4gIGdldCgpOiBMb2dnZXIge1xuICAgIHJldHVybiB0aGlzLmdlbmVyYXRlKHRoaXMubGV2ZWwpO1xuICB9XG59XG4iXX0=

package/lib/winston.d.ts

@@ -0,0 +1,15 @@
+import { LoggerFactory } from "./Factory";
+import { Logger } from "./interfaces";
+import * as winston from "winston";
+import { LogLevel } from "./constants";
+export declare class WinstonLoggerFactory extends LoggerFactory {
+    constructor(level: LogLevel);
+    protected generate(lvl: LogLevel, clazz?: string, method?: string): winston.Logger;
+    forClass(clazz: {
+        new (...args: any[]): any;
+    }): Logger;
+    forMethod(clazz: {
+        new (...args: any[]): any;
+    }, method: ((...args: any[]) => any) | string): Logger;
+    get(): Logger;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decaf-ts/logging",
-  "version": "0.0.17",
+  "version": "0.1.0",
   "description": "simple winston inspired wrapper for cross lib logging",
   "type": "module",
   "exports": {
@@ -13,21 +13,21 @@
       "import": "./lib/esm/winston.js"
     }
   },
-  "types": "dist/types/index.d.ts",
+  "types": "lib/index.d.ts",
   "scripts": {
     "do-install": "TOKEN=$(cat .token) npm install",
-    "update-dependencies": "rimraf node_modules/@decaf-ts package-lock.json && npm run do-install",
-    "update-scripts": "node ./bin/update-scripts.cjs",
-    "on-first-run": "node ./bin/update-scripts.cjs --boot",
+    "update-dependencies": "npm update @decaf-ts/*",
+    "update-scripts": "npx update-scripts",
+    "on-first-run": "npx update-scripts --boot",
     "set-git-auth": "git config url.\"https://api:$(cat .token)@github.com/\".insteadOf \"https://github.com/\" && git config url.\"https://ssh:$(cat .token)@github.com/\".insteadOf \"ssh://git@github.com/\" && git config url.\"https://git:$(cat .token)@github.com/\".insteadOf \"git@github.com:\"",
     "flash-forward": "npx npm-check-updates -u && npm run do-install",
     "reset": "rm -rf * && git checkout . && git pull && npm run do-install",
-    "build": "rimraf ./lib && rimraf ./dist && gulp dev",
-    "build:prod": "rimraf ./lib && rimraf ./dist && gulp prod",
+    "build": "npx build-scripts --dev",
+    "build:prod": "npx build-scripts --prod",
     "test": "jest --runInBand --coverage --detectOpenHandles",
     "test:unit": "jest --testPathPattern=\"/tests/unit\" --passWithNoTests --detectOpenHandles",
     "test:integration": "jest --testPathPattern=\"/tests/(integration)\" --passWithNoTests --detectOpenHandles",
-    "test:all": "jest --testPathPattern=\"/tests/(unit|integration)\" --passWithNoTests --detectOpenHandles",
+    "test:all": "jest --testPathPattern=\"/tests\" --passWithNoTests --detectOpenHandles",
     "test:circular": "dpdm -T --no-warning --no-tree ./src/index.ts",
     "coverage": "rimraf ./workdocs/reports/data/*.json && npm run test:all -- --coverage --config=./workdocs/reports/jest.coverage.config.ts",
     "lint": "eslint .",
@@ -37,7 +37,7 @@
     "clean-publish": "npx clean-publish",
     "drawings": "for FILE in workdocs/drawings/*.drawio; do echo \"converting $FILE to image...\" && docker run --rm -v $(pwd):/data rlespinasse/drawio-export --format png $FILE; done && cp -rf workdocs/drawings/export/* workdocs/resources/",
     "uml": "cd workdocs/uml && for FILE in ./*.puml; do docker run --rm -v $(pwd):/work -w /work miy4/plantuml -DPLANTUML_LIMIT_SIZE=8192 -tpng $FILE; done && cd ../.. && cp -fr workdocs/uml/*.png workdocs/resources/",
-    "docs": "npx rimraf ./docs && mkdir docs && npm run do-install -- better-docs taffydb && gulp docs; npm remove better-docs taffydb",
+    "docs": "npx rimraf ./docs && mkdir docs && npx build-scripts --docs",
     "publish-docs": "docker run -it --rm --user $(id -u):$(id -g) -v \"$(pwd)/workdocs/confluence:/content\" -e ATLASSIAN_API_TOKEN=$(cat .confluence-token) ghcr.io/markdown-confluence/publish:latest"
   },
   "repository": {
@@ -64,50 +64,37 @@
   },
   "homepage": "https://github.com/decaf-ts/logging#readme",
   "devDependencies": {
-    "@eslint/js": "^9.23.0",
+    "@decaf-ts/utils": "latest",
+    "@eslint/js": "^9.25.1",
+    "@rollup/plugin-commonjs": "^28.0.3",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-typescript": "^12.1.2",
     "@stylistic/eslint-plugin": "^4.2.0",
     "@types/jest": "^29.5.14",
-    "@types/prompts": "^2.4.9",
     "clean-publish": "^5.1.0",
     "dpdm": "^3.14.0",
-    "eslint": "^9.23.0",
-    "eslint-config-prettier": "^10.1.1",
-    "eslint-plugin-prettier": "^5.2.3",
+    "eslint": "^9.25.1",
+    "eslint-config-prettier": "^10.1.2",
+    "eslint-plugin-prettier": "^5.2.6",
     "globals": "^16.0.0",
-    "gulp": "^5.0.0",
-    "gulp-if": "^3.0.0",
-    "gulp-rename": "^2.0.0",
-    "gulp-replace": "^1.1.4",
-    "gulp-run-command": "^0.0.10",
-    "gulp-sourcemaps": "^2.6.5",
-    "gulp-typescript": "^6.0.0-alpha.1",
-    "gulp-uglify": "^3.0.2",
     "jest": "^29.7.0",
     "jest-html-reporters": "^3.1.7",
     "jest-junit": "^16.0.0",
     "jsdoc": "^4.0.4",
     "jsdoc-mermaid": "^1.0.0",
     "markdown-include": "^0.4.3",
-    "merge-stream": "^2.0.0",
     "minimist": "^1.2.8",
     "nodemon": "^3.1.9",
-    "npm-check-updates": "^17.1.16",
+    "npm-check-updates": "^18.0.0",
     "prettier": "3.5.3",
-    "prompts": "^2.4.2",
     "rimraf": "^6.0.1",
-    "ts-jest": "^29.2.6",
+    "rollup": "^4.40.0",
+    "ts-jest": "^29.3.2",
     "ts-loader": "^9.5.2",
     "ts-node": "^10.9.2",
-    "typescript": "^5.8.2",
-    "typescript-eslint": "^8.27.0",
-    "vinyl-named": "^1.1.0",
-    "webpack-node-externals": "^3.0.0",
-    "webpack-stream": "^7.0.0",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.31.0",
     "winston": "^3.17.0"
-  },
-  "overrides": {
-    "gulp-run-command": {
-      "cross-spawn": "^7.0.6"
-    }
   }
 }

package/dist/esm/logging.js

@@ -1 +0,0 @@
-var e={317:(e,t)=>{Object.defineProperty(t,"__esModule",{value:!0})},552:(e,t,o)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.toLogLevel=function(e){if(e.toString()in r.NumericLogLevels)return r.NumericLogLevels[e.toString()];throw new Error(`Invalid level: ${e.toString()}`)};const r=o(640)},563:(e,t)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.LoggerFactory=void 0,t.LoggerFactory=class{constructor(e){this.level=e}}},640:(e,t)=>{var o;Object.defineProperty(t,"__esModule",{value:!0}),t.NumericLogLevels=t.LogLevel=void 0,function(e){e.Fatal="fatal",e.Error="error",e.Warn="warn",e.Info="info",e.Http="http",e.Verbose="verbose",e.Debug="debug",e.Silly="silly"}(o||(t.LogLevel=o={})),t.NumericLogLevels={error:0,warn:1,info:2,http:3,verbose:4,debug:5,silly:6}},729:function(e,t,o){var r=this&&this.__createBinding||(Object.create?function(e,t,o,r){void 0===r&&(r=o);var s=Object.getOwnPropertyDescriptor(t,o);s&&!("get"in s?!t.__esModule:s.writable||s.configurable)||(s={enumerable:!0,get:function(){return t[o]}}),Object.defineProperty(e,r,s)}:function(e,t,o,r){void 0===r&&(r=o),e[r]=t[o]}),s=this&&this.__exportStar||function(e,t){for(var o in e)"default"===o||Object.prototype.hasOwnProperty.call(t,o)||r(t,e,o)};Object.defineProperty(t,"__esModule",{value:!0}),t.VERSION=void 0,s(o(640),t),s(o(760),t),s(o(563),t),s(o(317),t),s(o(916),t),s(o(552),t),t.VERSION="0.0.17"},760:(e,t,o)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.DefaultLoggerFactory=void 0;const r=o(563),s=o(640),l=o(552);class n{constructor(e,t,o){this.level=e,this.clazz=t,this.method=o}log(e,t,o,r){if((0,l.toLogLevel)(e)<(0,l.toLogLevel)(this.level))return;const{context:n,app:i}=o||{},a=`${r?`[${r}]`:""}${i?`[${i}]`:""}${n?`[${n}]`:""}${this.clazz?`[${this.clazz}]`:""}${this.method?`[${this.method}]`:""} ${t}`;switch(e){case s.LogLevel.Fatal:case s.LogLevel.Error:return console.error(a);case s.LogLevel.Warn:return console.warn(a);case s.LogLevel.Info:return console.info(a);case s.LogLevel.Http:case s.LogLevel.Verbose:case s.LogLevel.Debug:case s.LogLevel.Silly:return console.debug(a);default:throw new Error(`Invalid log level: ${e}`)}}silly(e,t,o){return this.log(s.LogLevel.Silly,e,t,o)}verbose(e,t,o){return this.log(s.LogLevel.Verbose,e,t,o)}debug(e,t,o){return this.log(s.LogLevel.Debug,e,t,o)}info(e,t,o){return this.log(s.LogLevel.Info,e,t,o)}warn(e,t,o){return this.log(s.LogLevel.Warn,e,t,o)}error(e,t,o){return this.log(s.LogLevel.Error,e,t,o)}emerg(e,t,o){return this.log(s.LogLevel.Fatal,e,t,o)}profile(e,t){throw new Error("Not implemented")}}class i extends r.LoggerFactory{constructor(e){super(e)}forClass(e){return new n(this.level,e.name)}forMethod(e,t){return new n(this.level,e.name,"string"==typeof t?t:t.name)}get(){return new n(this.level)}}t.DefaultLoggerFactory=i},916:(e,t,o)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.Logging=void 0;const r=o(640),s=o(760);class l{static{this._level=r.LogLevel.Info}static{this._factory=s.DefaultLoggerFactory}static{this.cacheByClass={}}static{this.cacheByClassMethod={}}constructor(){}static get level(){return this._level}static set level(e){this._level=e}static get instance(){return this._instance||(this._instance=new this._factory(l.level)),this._instance}static set factory(e){this._factory=e}static forClass(e){const t=e.name;return t in this.cacheByClass||(this.cacheByClass[t]=l.instance.forClass(e)),this.cacheByClass[t]}static forMethod(e,t){const o=e.name;o in this.cacheByClassMethod||(this.cacheByClassMethod[o]={});const r="string"==typeof t?t:t.name;return r in this.cacheByClassMethod[o]||(this.cacheByClassMethod[o][r]=l.instance.forMethod(e,t)),this.cacheByClassMethod[o][r]}static get(){return this.global||(this.global=l.instance.get()),this.global}}t.Logging=l}},t={};!function o(r){var s=t[r];if(void 0!==s)return s.exports;var l=t[r]={exports:{}};return e[r].call(l.exports,l,l.exports,o),l.exports}(729);

package/dist/logging.js

@@ -1 +0,0 @@
-!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define("logging",[],t):"object"==typeof exports?exports.logging=t():e.logging=t()}(this,(()=>(()=>{"use strict";var e={317:(e,t)=>{Object.defineProperty(t,"__esModule",{value:!0})},552:(e,t,o)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.toLogLevel=function(e){if(e.toString()in r.NumericLogLevels)return r.NumericLogLevels[e.toString()];throw new Error(`Invalid level: ${e.toString()}`)};const r=o(640)},563:(e,t)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.LoggerFactory=void 0,t.LoggerFactory=class{constructor(e){this.level=e}}},640:(e,t)=>{var o;Object.defineProperty(t,"__esModule",{value:!0}),t.NumericLogLevels=t.LogLevel=void 0,function(e){e.Fatal="fatal",e.Error="error",e.Warn="warn",e.Info="info",e.Http="http",e.Verbose="verbose",e.Debug="debug",e.Silly="silly"}(o||(t.LogLevel=o={})),t.NumericLogLevels={error:0,warn:1,info:2,http:3,verbose:4,debug:5,silly:6}},729:function(e,t,o){var r=this&&this.__createBinding||(Object.create?function(e,t,o,r){void 0===r&&(r=o);var s=Object.getOwnPropertyDescriptor(t,o);s&&!("get"in s?!t.__esModule:s.writable||s.configurable)||(s={enumerable:!0,get:function(){return t[o]}}),Object.defineProperty(e,r,s)}:function(e,t,o,r){void 0===r&&(r=o),e[r]=t[o]}),s=this&&this.__exportStar||function(e,t){for(var o in e)"default"===o||Object.prototype.hasOwnProperty.call(t,o)||r(t,e,o)};Object.defineProperty(t,"__esModule",{value:!0}),t.VERSION=void 0,s(o(640),t),s(o(760),t),s(o(563),t),s(o(317),t),s(o(916),t),s(o(552),t),t.VERSION="0.0.17"},760:(e,t,o)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.DefaultLoggerFactory=void 0;const r=o(563),s=o(640),l=o(552);class n{constructor(e,t,o){this.level=e,this.clazz=t,this.method=o}log(e,t,o,r){if((0,l.toLogLevel)(e)<(0,l.toLogLevel)(this.level))return;const{context:n,app:i}=o||{},a=`${r?`[${r}]`:""}${i?`[${i}]`:""}${n?`[${n}]`:""}${this.clazz?`[${this.clazz}]`:""}${this.method?`[${this.method}]`:""} ${t}`;switch(e){case s.LogLevel.Fatal:case s.LogLevel.Error:return console.error(a);case s.LogLevel.Warn:return console.warn(a);case s.LogLevel.Info:return console.info(a);case s.LogLevel.Http:case s.LogLevel.Verbose:case s.LogLevel.Debug:case s.LogLevel.Silly:return console.debug(a);default:throw new Error(`Invalid log level: ${e}`)}}silly(e,t,o){return this.log(s.LogLevel.Silly,e,t,o)}verbose(e,t,o){return this.log(s.LogLevel.Verbose,e,t,o)}debug(e,t,o){return this.log(s.LogLevel.Debug,e,t,o)}info(e,t,o){return this.log(s.LogLevel.Info,e,t,o)}warn(e,t,o){return this.log(s.LogLevel.Warn,e,t,o)}error(e,t,o){return this.log(s.LogLevel.Error,e,t,o)}emerg(e,t,o){return this.log(s.LogLevel.Fatal,e,t,o)}profile(e,t){throw new Error("Not implemented")}}class i extends r.LoggerFactory{constructor(e){super(e)}forClass(e){return new n(this.level,e.name)}forMethod(e,t){return new n(this.level,e.name,"string"==typeof t?t:t.name)}get(){return new n(this.level)}}t.DefaultLoggerFactory=i},916:(e,t,o)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.Logging=void 0;const r=o(640),s=o(760);class l{static{this._level=r.LogLevel.Info}static{this._factory=s.DefaultLoggerFactory}static{this.cacheByClass={}}static{this.cacheByClassMethod={}}constructor(){}static get level(){return this._level}static set level(e){this._level=e}static get instance(){return this._instance||(this._instance=new this._factory(l.level)),this._instance}static set factory(e){this._factory=e}static forClass(e){const t=e.name;return t in this.cacheByClass||(this.cacheByClass[t]=l.instance.forClass(e)),this.cacheByClass[t]}static forMethod(e,t){const o=e.name;o in this.cacheByClassMethod||(this.cacheByClassMethod[o]={});const r="string"==typeof t?t:t.name;return r in this.cacheByClassMethod[o]||(this.cacheByClassMethod[o][r]=l.instance.forMethod(e,t)),this.cacheByClassMethod[o][r]}static get(){return this.global||(this.global=l.instance.get()),this.global}}t.Logging=l}},t={};return function o(r){var s=t[r];if(void 0!==s)return s.exports;var l=t[r]={exports:{}};return e[r].call(l.exports,l,l.exports,o),l.exports}(729)})()));