@ncfour-us/logging 0.0.8

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2024 Tim Hahn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# replace this

package/lib/index.d.ts

@@ -0,0 +1 @@
+export { LogLevel, Logger } from './logging.js';

package/lib/index.js

@@ -0,0 +1,3 @@
+// Copyright (c) 2024 Tim Hahn
+export { LogLevel, Logger } from './logging.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsOEJBQThCO0FBRTlCLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLE1BQU0sY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IChjKSAyMDI0IFRpbSBIYWhuXG5cbmV4cG9ydCB7IExvZ0xldmVsLCBMb2dnZXIgfSBmcm9tICcuL2xvZ2dpbmcuanMnO1xuIl19

package/lib/logger-factory.d.ts

@@ -0,0 +1,4 @@
+import { ILogger, LoggerProps, LoggerSetLoggerProps } from './logger.js';
+export { ILogger, LoggerProps, LoggerSetLoggerProps };
+export type LoggerType = 'simple' | 'winston';
+export declare function createLogger(type: LoggerType, props?: LoggerProps): ILogger;

package/lib/logger-factory.js

@@ -0,0 +1,8 @@
+// Copyright (C) 2025 Tim Hahn
+import { SimpleLogger } from './simple-logger.js';
+import { WinstonLogger } from './winston-logger.js';
+export function createLogger(type, props) {
+    const retService = type === 'simple' ? SimpleLogger.getSimpleLogger(props) : WinstonLogger.getWinstonLogger(props);
+    return retService;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLWZhY3RvcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvbG9nZ2VyLWZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsOEJBQThCO0FBRzlCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNsRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFLcEQsTUFBTSxVQUFVLFlBQVksQ0FBQyxJQUFnQixFQUFFLEtBQW1CO0lBQ2hFLE1BQU0sVUFBVSxHQUNkLElBQUksS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLFlBQVksQ0FBQyxlQUFlLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLGFBQWEsQ0FBQyxnQkFBZ0IsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUVsRyxPQUFPLFVBQVUsQ0FBQztBQUNwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IChDKSAyMDI1IFRpbSBIYWhuXG5cbmltcG9ydCB7IElMb2dnZXIsIExvZ2dlclByb3BzLCBMb2dnZXJTZXRMb2dnZXJQcm9wcyB9IGZyb20gJy4vbG9nZ2VyLmpzJztcbmltcG9ydCB7IFNpbXBsZUxvZ2dlciB9IGZyb20gJy4vc2ltcGxlLWxvZ2dlci5qcyc7XG5pbXBvcnQgeyBXaW5zdG9uTG9nZ2VyIH0gZnJvbSAnLi93aW5zdG9uLWxvZ2dlci5qcyc7XG5cbmV4cG9ydCB7IElMb2dnZXIsIExvZ2dlclByb3BzLCBMb2dnZXJTZXRMb2dnZXJQcm9wcyB9O1xuZXhwb3J0IHR5cGUgTG9nZ2VyVHlwZSA9ICdzaW1wbGUnIHwgJ3dpbnN0b24nO1xuXG5leHBvcnQgZnVuY3Rpb24gY3JlYXRlTG9nZ2VyKHR5cGU6IExvZ2dlclR5cGUsIHByb3BzPzogTG9nZ2VyUHJvcHMpOiBJTG9nZ2VyIHtcbiAgY29uc3QgcmV0U2VydmljZTogSUxvZ2dlciA9XG4gICAgdHlwZSA9PT0gJ3NpbXBsZScgPyBTaW1wbGVMb2dnZXIuZ2V0U2ltcGxlTG9nZ2VyKHByb3BzKSA6IFdpbnN0b25Mb2dnZXIuZ2V0V2luc3RvbkxvZ2dlcihwcm9wcyk7XG5cbiAgcmV0dXJuIHJldFNlcnZpY2U7XG59XG4iXX0=

package/lib/logger-types.d.ts

@@ -0,0 +1,29 @@
+export type LoggerLevel = 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace';
+export type LoggerType = 'simple' | 'winston';
+export interface LoggerProps {
+    name?: string;
+    level?: LoggerLevel;
+    json?: boolean;
+    color?: boolean;
+    silent?: boolean;
+    timestamp?: boolean;
+}
+export interface LoggerSetLoggerProps {
+    level?: LoggerLevel;
+    json?: boolean;
+    color?: boolean;
+    silent?: boolean;
+    timestamp?: boolean;
+}
+export interface ILogger {
+    getName(): string;
+    getType(): LoggerType;
+    setLoggerProps(props: LoggerSetLoggerProps): void;
+    log(level: LoggerLevel, message: string, ...rest: (string | number | boolean | object)[]): void;
+    fatal(message: string, ...rest: (string | number | boolean | object)[]): void;
+    error(message: string, ...rest: (string | number | boolean | object)[]): void;
+    warn(message: string, ...rest: (string | number | boolean | object)[]): void;
+    info(message: string, ...rest: (string | number | boolean | object)[]): void;
+    debug(message: string, ...rest: (string | number | boolean | object)[]): void;
+    trace(message: string, ...rest: (string | number | boolean | object)[]): void;
+}

package/lib/logger-types.js

@@ -0,0 +1,3 @@
+// Copyright (C) 2025 Tim Hahn
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLXR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2xvZ2dlci10eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSw4QkFBOEIiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgKEMpIDIwMjUgVGltIEhhaG5cblxuZXhwb3J0IHR5cGUgTG9nZ2VyTGV2ZWwgPSAnZmF0YWwnIHwgJ2Vycm9yJyB8ICd3YXJuJyB8ICdpbmZvJyB8ICdkZWJ1ZycgfCAndHJhY2UnO1xuXG5leHBvcnQgdHlwZSBMb2dnZXJUeXBlID0gJ3NpbXBsZScgfCAnd2luc3Rvbic7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTG9nZ2VyUHJvcHMge1xuICBuYW1lPzogc3RyaW5nO1xuICBsZXZlbD86IExvZ2dlckxldmVsO1xuICBqc29uPzogYm9vbGVhbjtcbiAgY29sb3I/OiBib29sZWFuO1xuICBzaWxlbnQ/OiBib29sZWFuO1xuICB0aW1lc3RhbXA/OiBib29sZWFuO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIExvZ2dlclNldExvZ2dlclByb3BzIHtcbiAgbGV2ZWw/OiBMb2dnZXJMZXZlbDtcbiAganNvbj86IGJvb2xlYW47XG4gIGNvbG9yPzogYm9vbGVhbjtcbiAgc2lsZW50PzogYm9vbGVhbjtcbiAgdGltZXN0YW1wPzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBJTG9nZ2VyIHtcbiAgZ2V0TmFtZSgpOiBzdHJpbmc7XG5cbiAgZ2V0VHlwZSgpOiBMb2dnZXJUeXBlO1xuXG4gIHNldExvZ2dlclByb3BzKHByb3BzOiBMb2dnZXJTZXRMb2dnZXJQcm9wcyk6IHZvaWQ7XG5cbiAgbG9nKGxldmVsOiBMb2dnZXJMZXZlbCwgbWVzc2FnZTogc3RyaW5nLCAuLi5yZXN0OiAoc3RyaW5nIHwgbnVtYmVyIHwgYm9vbGVhbiB8IG9iamVjdClbXSk6IHZvaWQ7XG5cbiAgZmF0YWwobWVzc2FnZTogc3RyaW5nLCAuLi5yZXN0OiAoc3RyaW5nIHwgbnVtYmVyIHwgYm9vbGVhbiB8IG9iamVjdClbXSk6IHZvaWQ7XG5cbiAgZXJyb3IobWVzc2FnZTogc3RyaW5nLCAuLi5yZXN0OiAoc3RyaW5nIHwgbnVtYmVyIHwgYm9vbGVhbiB8IG9iamVjdClbXSk6IHZvaWQ7XG5cbiAgd2FybihtZXNzYWdlOiBzdHJpbmcsIC4uLnJlc3Q6IChzdHJpbmcgfCBudW1iZXIgfCBib29sZWFuIHwgb2JqZWN0KVtdKTogdm9pZDtcblxuICBpbmZvKG1lc3NhZ2U6IHN0cmluZywgLi4ucmVzdDogKHN0cmluZyB8IG51bWJlciB8IGJvb2xlYW4gfCBvYmplY3QpW10pOiB2b2lkO1xuXG4gIGRlYnVnKG1lc3NhZ2U6IHN0cmluZywgLi4ucmVzdDogKHN0cmluZyB8IG51bWJlciB8IGJvb2xlYW4gfCBvYmplY3QpW10pOiB2b2lkO1xuXG4gIHRyYWNlKG1lc3NhZ2U6IHN0cmluZywgLi4ucmVzdDogKHN0cmluZyB8IG51bWJlciB8IGJvb2xlYW4gfCBvYmplY3QpW10pOiB2b2lkO1xufVxuIl19

package/lib/logger.d.ts

@@ -0,0 +1,3 @@
+import { ILogger, LoggerType, LoggerLevel, LoggerProps, LoggerSetLoggerProps } from './logger-types.js';
+export { ILogger, LoggerLevel, LoggerProps, LoggerSetLoggerProps };
+export declare function createLogger(type: LoggerType, props?: LoggerProps): ILogger;

package/lib/logger.js

@@ -0,0 +1,49 @@
+// Copyright (C) 2025 Tim Hahn
+// const isBrowser = typeof window !== 'undefined' && globalThis === window;
+const isNode = typeof process !== 'undefined' && globalThis.process === process;
+const loggerClasses = [];
+const loggers = [];
+async function initializeLoggerClasses() {
+    let createWinstonLogger;
+    let createSimpleLogger;
+    ({ createSimpleLogger } = await import('./simple-logger.js'));
+    loggerClasses[0] = {
+        type: 'simple',
+        loggerCreator: createSimpleLogger,
+    };
+    if (isNode) {
+        ({ createWinstonLogger } = await import('./winston-logger.js'));
+        loggerClasses[1] = {
+            type: 'winston',
+            loggerCreator: createWinstonLogger,
+        };
+    }
+}
+export function createLogger(type, props) {
+    const loggerName = props?.name ?? 'default'; // covers case where props.name === ''
+    const existingLogger = loggers.find((logger) => logger.getName() === loggerName);
+    if (existingLogger) {
+        if (existingLogger.getType() !== type) {
+            existingLogger.warn(`createLogger: existing Logger found does not match type requested: ${type}`);
+        }
+        if (props) {
+            existingLogger.warn('createLogger: existing Logger found, supplied props ignored, use setLoggerProps()');
+        }
+        return existingLogger;
+    }
+    const newLoggerProps = { ...props };
+    newLoggerProps.name = loggerName;
+    let loggerClass = loggerClasses.find((item) => item.type === type);
+    let newLogger = undefined;
+    if (loggerClass) {
+        newLogger = loggerClass.loggerCreator(newLoggerProps);
+    }
+    else {
+        newLogger = loggerClasses[0].loggerCreator(newLoggerProps);
+        newLogger.log('warn', `loggerType: ${type} not found, falling back to SimpleLogger`);
+    }
+    loggers.push(newLogger);
+    return newLogger;
+}
+await initializeLoggerClasses();
+//# sourceMappingURL=data:application/json;base64,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

package/lib/logging.d.ts

@@ -0,0 +1,28 @@
+export declare enum LogLevel {
+    SEVERE = 10,
+    ERROR = 20,
+    INFO = 30,
+    DEBUG = 40,
+    ALL = 100
+}
+export declare class Logger {
+    static getLogger(component?: string): Logger;
+    private component;
+    private logLevel;
+    private insertPrefix;
+    private insertTimestamp;
+    private insertLevel;
+    private useColor;
+    private constructor();
+    setLevel(logLevel: LogLevel): void;
+    setInsertPrefix(insertPrefix: boolean): void;
+    setInsertTimestamp(insertTimestamp: boolean): void;
+    setInsertLevel(insertLevel: boolean): void;
+    setUseColor(useColor: boolean): void;
+    debug(message: string): void;
+    info(message: string): void;
+    error(message: string): void;
+    severe(message: string): void;
+    log(level: LogLevel, message: string): void;
+    private emitMessage;
+}

package/lib/logging.js

@@ -0,0 +1,97 @@
+// Copyright (c) 2024 Tim Hahn
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["SEVERE"] = 10] = "SEVERE";
+    LogLevel[LogLevel["ERROR"] = 20] = "ERROR";
+    LogLevel[LogLevel["INFO"] = 30] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 40] = "DEBUG";
+    LogLevel[LogLevel["ALL"] = 100] = "ALL";
+})(LogLevel || (LogLevel = {}));
+const logLevelStrings = {
+    10: 'SEV',
+    20: 'ERR',
+    30: 'INF',
+    40: 'DEB',
+    100: 'ALL',
+};
+const loggers = {};
+export class Logger {
+    // Factory method (static)
+    static getLogger(component) {
+        let logger = loggers.root;
+        if (component) {
+            if (!(component in loggers)) {
+                loggers[component] = new Logger(component);
+            }
+            logger = loggers[component];
+        }
+        return logger;
+    }
+    component;
+    logLevel;
+    insertPrefix;
+    insertTimestamp;
+    insertLevel;
+    useColor;
+    // callable only from static methods
+    constructor(component) {
+        this.component = component;
+        this.logLevel = LogLevel.INFO;
+        this.insertPrefix = true;
+        this.insertTimestamp = false;
+        this.insertLevel = false;
+        this.useColor = false;
+    }
+    setLevel(logLevel) {
+        this.logLevel = logLevel;
+    }
+    setInsertPrefix(insertPrefix) {
+        this.insertPrefix = insertPrefix;
+    }
+    setInsertTimestamp(insertTimestamp) {
+        this.insertTimestamp = insertTimestamp;
+    }
+    setInsertLevel(insertLevel) {
+        this.insertLevel = insertLevel;
+    }
+    setUseColor(useColor) {
+        this.useColor = useColor;
+    }
+    debug(message) {
+        this.log(LogLevel.DEBUG, message);
+    }
+    info(message) {
+        this.log(LogLevel.INFO, message);
+    }
+    error(message) {
+        this.log(LogLevel.ERROR, message);
+    }
+    severe(message) {
+        this.log(LogLevel.SEVERE, message);
+    }
+    log(level, message) {
+        if (this.logLevel >= level) {
+            this.emitMessage(level, message);
+        }
+    }
+    emitMessage(level, message) {
+        let prefixStr = '';
+        let levelStr = '';
+        let timestampStr = '';
+        if (this.insertPrefix) {
+            if (this.insertLevel) {
+                levelStr = `[${logLevelStrings[level]}] `;
+            }
+            if (this.insertTimestamp) {
+                const date = new Date();
+                timestampStr = `[${date.toISOString()}] `;
+            }
+            if (this.useColor) {
+            }
+            prefixStr = `${levelStr}${timestampStr}(${this.component}): `;
+        }
+        console.log(`${prefixStr}${message}`);
+    }
+}
+loggers.root = Logger.getLogger('root');
+//# sourceMappingURL=data:application/json;base64,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

package/lib/simple-logger.d.ts

@@ -0,0 +1,23 @@
+import { ILogger, LoggerType, LoggerLevel, LoggerProps, LoggerSetLoggerProps } from './logger-types.js';
+export declare class SimpleLogger implements ILogger {
+    name: string;
+    level: string;
+    json: boolean;
+    color: boolean;
+    silent: boolean;
+    timestamp: boolean;
+    private numericLevel;
+    constructor(props?: LoggerProps);
+    private stringifyLogRecord;
+    getName(): string;
+    getType(): LoggerType;
+    setLoggerProps(props: LoggerSetLoggerProps): void;
+    log(level: LoggerLevel, message: string, ...rest: (string | number | boolean | object)[]): void;
+    fatal(message: string, ...rest: (string | number | boolean | object)[]): void;
+    error(message: string, ...rest: (string | number | boolean | object)[]): void;
+    warn(message: string, ...rest: (string | number | boolean | object)[]): void;
+    info(message: string, ...rest: (string | number | boolean | object)[]): void;
+    debug(message: string, ...rest: (string | number | boolean | object)[]): void;
+    trace(message: string, ...rest: (string | number | boolean | object)[]): void;
+}
+export declare function createSimpleLogger(props?: LoggerProps): ILogger;

package/lib/simple-logger.js

@@ -0,0 +1,113 @@
+// Copyright (C) 2025 Tim Hahn
+// import { Date } from 'date';
+import chalk from 'chalk';
+const logLevels = {
+    fatal: {
+        numericLevel: 10,
+        colorizer: chalk.magenta,
+    },
+    error: {
+        numericLevel: 20,
+        colorizer: chalk.red,
+    },
+    warn: {
+        numericLevel: 30,
+        colorizer: chalk.yellow,
+    },
+    info: {
+        numericLevel: 40,
+        colorizer: chalk.green,
+    },
+    debug: {
+        numericLevel: 50,
+        colorizer: chalk.white,
+    },
+    trace: {
+        numericLevel: 60,
+        colorizer: chalk.gray,
+    },
+};
+export class SimpleLogger {
+    name;
+    level;
+    json;
+    color;
+    silent;
+    timestamp;
+    numericLevel;
+    constructor(props) {
+        this.name = props?.name ?? 'default';
+        this.level = props?.level ?? 'error';
+        this.json = props?.json ?? true;
+        this.color = props?.color ?? false;
+        this.silent = props?.silent ?? false;
+        this.timestamp = props?.timestamp ?? true;
+        this.numericLevel = logLevels[this.level].numericLevel;
+    }
+    stringifyLogRecord(level, message, ...rest) {
+        let messageString = '';
+        if (this.json) {
+            messageString = JSON.stringify({
+                level: level,
+                timestamp: new Date(Date.now()).toISOString(),
+                name: this.name,
+                message: message,
+                ...rest,
+            });
+        }
+        else {
+            // messageString = messageString + this.timestamp ? '[' + new Date(Date.now()).toISOString() : "[";
+            messageString =
+                messageString + (this.timestamp ? `[${new Date(Date.now()).toISOString()} ` : '[');
+            messageString = messageString + (this.name !== 'default' ? `${this.name} ` : '');
+            messageString =
+                messageString + `(${this.color ? logLevels[level].colorizer(level) : level})]`;
+            messageString =
+                messageString + ` ${this.color ? logLevels[level].colorizer(message) : message}`;
+            messageString =
+                rest.length > 0 ? messageString + ` ${JSON.stringify({ ...rest })}` : messageString;
+        }
+        return messageString;
+    }
+    getName() {
+        return this.name;
+    }
+    getType() {
+        return 'simple';
+    }
+    setLoggerProps(props) {
+        this.level = props?.level ?? this.level;
+        this.json = props?.json ?? this.json;
+        this.color = props?.color ?? this.color;
+        this.silent = props?.silent ?? this.silent;
+        this.timestamp = props?.timestamp ?? this.timestamp;
+        this.numericLevel = logLevels[this.level].numericLevel;
+    }
+    log(level, message, ...rest) {
+        if (!this.silent && logLevels[level].numericLevel <= this.numericLevel) {
+            console.log(this.stringifyLogRecord(level, message, ...rest));
+        }
+    }
+    fatal(message, ...rest) {
+        this.log('fatal', message, ...rest);
+    }
+    error(message, ...rest) {
+        this.log('error', message, ...rest);
+    }
+    warn(message, ...rest) {
+        this.log('warn', message, ...rest);
+    }
+    info(message, ...rest) {
+        this.log('info', message, ...rest);
+    }
+    debug(message, ...rest) {
+        this.log('debug', message, ...rest);
+    }
+    trace(message, ...rest) {
+        this.log('trace', message, ...rest);
+    }
+}
+export function createSimpleLogger(props) {
+    return new SimpleLogger(props);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simple-logger.js","sourceRoot":"","sources":["../src/simple-logger.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (C) 2025 Tim Hahn\n\n// import { Date } from 'date';\nimport chalk, { Chalk } from 'chalk';\n\nimport {\n  ILogger,\n  LoggerType,\n  LoggerLevel,\n  LoggerProps,\n  LoggerSetLoggerProps,\n} from './logger-types.js';\n\nconst logLevels: { [key: string]: { numericLevel: number; colorizer: Chalk } } = {\n  fatal: {\n    numericLevel: 10,\n    colorizer: chalk.magenta,\n  },\n  error: {\n    numericLevel: 20,\n    colorizer: chalk.red,\n  },\n  warn: {\n    numericLevel: 30,\n    colorizer: chalk.yellow,\n  },\n  info: {\n    numericLevel: 40,\n    colorizer: chalk.green,\n  },\n  debug: {\n    numericLevel: 50,\n    colorizer: chalk.white,\n  },\n  trace: {\n    numericLevel: 60,\n    colorizer: chalk.gray,\n  },\n};\n\nexport class SimpleLogger implements ILogger {\n  name: string;\n  level: string;\n  json: boolean;\n  color: boolean;\n  silent: boolean;\n  timestamp: boolean;\n\n  private numericLevel: number;\n\n  constructor(props?: LoggerProps) {\n    this.name = props?.name ?? 'default';\n    this.level = props?.level ?? 'error';\n    this.json = props?.json ?? true;\n    this.color = props?.color ?? false;\n    this.silent = props?.silent ?? false;\n    this.timestamp = props?.timestamp ?? true;\n\n    this.numericLevel = logLevels[this.level].numericLevel;\n  }\n\n  private stringifyLogRecord(\n    level: LoggerLevel,\n    message: string,\n    ...rest: (string | number | boolean | object)[]\n  ): string {\n    let messageString = '';\n\n    if (this.json) {\n      messageString = JSON.stringify({\n        level: level,\n        timestamp: new Date(Date.now()).toISOString(),\n        name: this.name,\n        message: message,\n        ...rest,\n      });\n    } else {\n      // messageString = messageString + this.timestamp ? '[' + new Date(Date.now()).toISOString() : \"[\";\n\n      messageString =\n        messageString + (this.timestamp ? `[${new Date(Date.now()).toISOString()} ` : '[');\n      messageString = messageString + (this.name !== 'default' ? `${this.name} ` : '');\n      messageString =\n        messageString + `(${this.color ? logLevels[level].colorizer(level) : level})]`;\n      messageString =\n        messageString + ` ${this.color ? logLevels[level].colorizer(message) : message}`;\n      messageString =\n        rest.length > 0 ? messageString + ` ${JSON.stringify({ ...rest })}` : messageString;\n    }\n\n    return messageString;\n  }\n\n  public getName(): string {\n    return this.name;\n  }\n\n  public getType(): LoggerType {\n    return 'simple';\n  }\n\n  public setLoggerProps(props: LoggerSetLoggerProps) {\n    this.level = props?.level ?? this.level;\n    this.json = props?.json ?? this.json;\n    this.color = props?.color ?? this.color;\n    this.silent = props?.silent ?? this.silent;\n    this.timestamp = props?.timestamp ?? this.timestamp;\n\n    this.numericLevel = logLevels[this.level].numericLevel;\n  }\n\n  public log(\n    level: LoggerLevel,\n    message: string,\n    ...rest: (string | number | boolean | object)[]\n  ): void {\n    if (!this.silent && logLevels[level].numericLevel <= this.numericLevel) {\n      console.log(this.stringifyLogRecord(level, message, ...rest));\n    }\n  }\n\n  public fatal(message: string, ...rest: (string | number | boolean | object)[]): void {\n    this.log('fatal', message, ...rest);\n  }\n\n  public error(message: string, ...rest: (string | number | boolean | object)[]): void {\n    this.log('error', message, ...rest);\n  }\n\n  public warn(message: string, ...rest: (string | number | boolean | object)[]): void {\n    this.log('warn', message, ...rest);\n  }\n\n  public info(message: string, ...rest: (string | number | boolean | object)[]): void {\n    this.log('info', message, ...rest);\n  }\n\n  public debug(message: string, ...rest: (string | number | boolean | object)[]): void {\n    this.log('debug', message, ...rest);\n  }\n\n  public trace(message: string, ...rest: (string | number | boolean | object)[]): void {\n    this.log('trace', message, ...rest);\n  }\n}\n\nexport function createSimpleLogger(props?: LoggerProps): ILogger {\n  return new SimpleLogger(props);\n}\n"]}

package/lib/winston-logger.d.ts

@@ -0,0 +1,2 @@
+import { ILogger, LoggerProps } from './logger-types.js';
+export declare function createWinstonLogger(props?: LoggerProps): ILogger;

package/lib/winston-logger.js

@@ -0,0 +1,103 @@
+// Copyright (C) 2025 Tim Hahn
+import winston from 'winston';
+const logLevels = {
+    fatal: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4,
+    trace: 5,
+};
+const logLevelColors = {
+    fatal: 'magenta',
+    error: 'red',
+    warn: 'yellow',
+    info: 'green',
+    debug: 'white',
+    trace: 'gray',
+};
+class WinstonLogger {
+    logger;
+    name;
+    level;
+    json;
+    color;
+    silent;
+    timestamp;
+    // private numericLevel: number;
+    constructor(props) {
+        this.name = props?.name ?? 'default';
+        this.level = props?.level ?? 'error';
+        this.json = props?.json ?? true;
+        this.color = props?.color ?? false;
+        this.silent = props?.silent ?? false;
+        this.timestamp = props?.timestamp ?? true;
+        this.logger = winston.createLogger(); // create an initial in the constructor, overwritten by initializeWinstonLogger()
+        this.initializeWinstonLogger();
+    }
+    getName() {
+        return this.name;
+    }
+    getType() {
+        return 'winston';
+    }
+    setLoggerProps(props) {
+        this.level = props?.level ?? this.level;
+        this.json = props?.json ?? this.json;
+        this.color = props?.color ?? this.color;
+        this.silent = props?.silent ?? this.silent;
+        this.timestamp = props?.timestamp ?? this.timestamp;
+        // Replace the logger completely, using the new configuration
+        this.initializeWinstonLogger();
+    }
+    initializeWinstonLogger() {
+        winston.addColors(logLevelColors); // set colors for the custom levels defined in the logger
+        // Build the output log format specification
+        // Order of how formats are combined matters here!!
+        let format = winston.format.combine();
+        if (this.timestamp) {
+            format = winston.format.combine(format, winston.format.timestamp());
+        }
+        if (this.json) {
+            format = winston.format.combine(format, winston.format.json());
+        }
+        else {
+            if (this.color) {
+                format = winston.format.combine(format, winston.format.colorize({ all: true }));
+            }
+            format = winston.format.combine(format, winston.format.printf((info) => `[${info.timestamp} ${this.name !== 'default' ? `${this.name} ` : ''}(${info.level})] ${info.message}`));
+        }
+        // Now create the logger
+        this.logger = winston.createLogger({
+            levels: logLevels,
+            level: this.level ?? 'error',
+            format: format,
+            transports: [new winston.transports.Console()],
+        });
+    }
+    log(level, message, ...rest) {
+        this.logger.log(level, message, ...rest);
+    }
+    fatal(message, ...rest) {
+        this.log('fatal', message, ...rest);
+    }
+    error(message, ...rest) {
+        this.log('error', message, ...rest);
+    }
+    warn(message, ...rest) {
+        this.log('warn', message, ...rest);
+    }
+    info(message, ...rest) {
+        this.log('info', message, ...rest);
+    }
+    debug(message, ...rest) {
+        this.log('debug', message, ...rest);
+    }
+    trace(message, ...rest) {
+        this.log('trace', message, ...rest);
+    }
+}
+export function createWinstonLogger(props) {
+    return new WinstonLogger(props);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"winston-logger.js","sourceRoot":"","sources":["../src/winston-logger.ts"],"names":[],"mappings":"AAAA,8BAA8B;AAE9B,OAAO,OAAO,MAAM,SAAS,CAAC;AAU9B,MAAM,SAAS,GAA8B;IAC3C,KAAK,EAAE,CAAC;IACR,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC;IACP,IAAI,EAAE,CAAC;IACP,KAAK,EAAE,CAAC;IACR,KAAK,EAAE,CAAC;CACT,CAAC;AAEF,MAAM,cAAc,GAA8B;IAChD,KAAK,EAAE,SAAS;IAChB,KAAK,EAAE,KAAK;IACZ,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,OAAO;IACb,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,MAAM;CACd,CAAC;AAEF,MAAM,aAAa;IACT,MAAM,CAAiB;IAE/B,IAAI,CAAS;IACb,KAAK,CAAS;IACd,IAAI,CAAU;IACd,KAAK,CAAU;IACf,MAAM,CAAU;IAChB,SAAS,CAAU;IAEnB,gCAAgC;IAEhC,YAAY,KAAmB;QAC7B,IAAI,CAAC,IAAI,GAAG,KAAK,EAAE,IAAI,IAAI,SAAS,CAAC;QACrC,IAAI,CAAC,KAAK,GAAG,KAAK,EAAE,KAAK,IAAI,OAAO,CAAC;QACrC,IAAI,CAAC,IAAI,GAAG,KAAK,EAAE,IAAI,IAAI,IAAI,CAAC;QAChC,IAAI,CAAC,KAAK,GAAG,KAAK,EAAE,KAAK,IAAI,KAAK,CAAC;QACnC,IAAI,CAAC,MAAM,GAAG,KAAK,EAAE,MAAM,IAAI,KAAK,CAAC;QACrC,IAAI,CAAC,SAAS,GAAG,KAAK,EAAE,SAAS,IAAI,IAAI,CAAC;QAE1C,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC,iFAAiF;QACvH,IAAI,CAAC,uBAAuB,EAAE,CAAC;IACjC,CAAC;IAEM,OAAO;QACZ,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAEM,OAAO;QACZ,OAAO,SAAS,CAAC;IACnB,CAAC;IAEM,cAAc,CAAC,KAA2B;QAC/C,IAAI,CAAC,KAAK,GAAG,KAAK,EAAE,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC;QACxC,IAAI,CAAC,IAAI,GAAG,KAAK,EAAE,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC;QACrC,IAAI,CAAC,KAAK,GAAG,KAAK,EAAE,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC;QACxC,IAAI,CAAC,MAAM,GAAG,KAAK,EAAE,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC;QAC3C,IAAI,CAAC,SAAS,GAAG,KAAK,EAAE,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC;QAEpD,6DAA6D;QAC7D,IAAI,CAAC,uBAAuB,EAAE,CAAC;IACjC,CAAC;IAEO,uBAAuB;QAC7B,OAAO,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,yDAAyD;QAE5F,4CAA4C;QAC5C,mDAAmD;QACnD,IAAI,MAAM,GAA2B,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QAE9D,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC;QACtE,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACd,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;QACjE,CAAC;aAAM,CAAC;YACN,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBACf,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;YAClF,CAAC;YACD,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAC7B,MAAM,EACN,OAAO,CAAC,MAAM,CAAC,MAAM,CACnB,CAAC,IAAI,EAAE,EAAE,CACP,IAAI,IAAI,CAAC,SAAmB,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,IAAI,CAAC,KAAK,MAAM,IAAI,CAAC,OAAiB,EAAE,CAC7H,CACF,CAAC;QACJ,CAAC;QAED,wBAAwB;QAExB,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;YACjC,MAAM,EAAE,SAAS;YACjB,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,OAAO;YAC5B,MAAM,EAAE,MAAM;YACd,UAAU,EAAE,CAAC,IAAI,OAAO,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;SAC/C,CAAC,CAAC;IACL,CAAC;IAEM,GAAG,CACR,KAAkB,EAClB,OAAe,EACf,GAAG,IAA4C;QAE/C,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;IAC3C,CAAC;IAEM,KAAK,CAAC,OAAe,EAAE,GAAG,IAA4C;QAC3E,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;IACtC,CAAC;IAEM,KAAK,CAAC,OAAe,EAAE,GAAG,IAA4C;QAC3E,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;IACtC,CAAC;IAEM,IAAI,CAAC,OAAe,EAAE,GAAG,IAA4C;QAC1E,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;IACrC,CAAC;IAEM,IAAI,CAAC,OAAe,EAAE,GAAG,IAA4C;QAC1E,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;IACrC,CAAC;IAEM,KAAK,CAAC,OAAe,EAAE,GAAG,IAA4C;QAC3E,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;IACtC,CAAC;IAEM,KAAK,CAAC,OAAe,EAAE,GAAG,IAA4C;QAC3E,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;IACtC,CAAC;CACF;AAED,MAAM,UAAU,mBAAmB,CAAC,KAAmB;IACrD,OAAO,IAAI,aAAa,CAAC,KAAK,CAAC,CAAC;AAClC,CAAC","sourcesContent":["// Copyright (C) 2025 Tim Hahn\n\nimport winston from 'winston';\n\nimport {\n  ILogger,\n  LoggerType,\n  LoggerLevel,\n  LoggerProps,\n  LoggerSetLoggerProps,\n} from './logger-types.js';\n\nconst logLevels: { [key: string]: number } = {\n  fatal: 0,\n  error: 1,\n  warn: 2,\n  info: 3,\n  debug: 4,\n  trace: 5,\n};\n\nconst logLevelColors: { [key: string]: string } = {\n  fatal: 'magenta',\n  error: 'red',\n  warn: 'yellow',\n  info: 'green',\n  debug: 'white',\n  trace: 'gray',\n};\n\nclass WinstonLogger implements ILogger {\n  private logger: winston.Logger;\n\n  name: string;\n  level: string;\n  json: boolean;\n  color: boolean;\n  silent: boolean;\n  timestamp: boolean;\n\n  // private numericLevel: number;\n\n  constructor(props?: LoggerProps) {\n    this.name = props?.name ?? 'default';\n    this.level = props?.level ?? 'error';\n    this.json = props?.json ?? true;\n    this.color = props?.color ?? false;\n    this.silent = props?.silent ?? false;\n    this.timestamp = props?.timestamp ?? true;\n\n    this.logger = winston.createLogger(); // create an initial in the constructor, overwritten by initializeWinstonLogger()\n    this.initializeWinstonLogger();\n  }\n\n  public getName() {\n    return this.name;\n  }\n\n  public getType(): LoggerType {\n    return 'winston';\n  }\n\n  public setLoggerProps(props: LoggerSetLoggerProps) {\n    this.level = props?.level ?? this.level;\n    this.json = props?.json ?? this.json;\n    this.color = props?.color ?? this.color;\n    this.silent = props?.silent ?? this.silent;\n    this.timestamp = props?.timestamp ?? this.timestamp;\n\n    // Replace the logger completely, using the new configuration\n    this.initializeWinstonLogger();\n  }\n\n  private initializeWinstonLogger() {\n    winston.addColors(logLevelColors); // set colors for the custom levels defined in the logger\n\n    // Build the output log format specification\n    // Order of how formats are combined matters here!!\n    let format: winston.Logform.Format = winston.format.combine();\n\n    if (this.timestamp) {\n      format = winston.format.combine(format, winston.format.timestamp());\n    }\n    if (this.json) {\n      format = winston.format.combine(format, winston.format.json());\n    } else {\n      if (this.color) {\n        format = winston.format.combine(format, winston.format.colorize({ all: true }));\n      }\n      format = winston.format.combine(\n        format,\n        winston.format.printf(\n          (info) =>\n            `[${info.timestamp as string} ${this.name !== 'default' ? `${this.name} ` : ''}(${info.level})] ${info.message as string}`,\n        ),\n      );\n    }\n\n    // Now create the logger\n\n    this.logger = winston.createLogger({\n      levels: logLevels,\n      level: this.level ?? 'error',\n      format: format,\n      transports: [new winston.transports.Console()],\n    });\n  }\n\n  public log(\n    level: LoggerLevel,\n    message: string,\n    ...rest: (string | number | boolean | object)[]\n  ): void {\n    this.logger.log(level, message, ...rest);\n  }\n\n  public fatal(message: string, ...rest: (string | number | boolean | object)[]): void {\n    this.log('fatal', message, ...rest);\n  }\n\n  public error(message: string, ...rest: (string | number | boolean | object)[]): void {\n    this.log('error', message, ...rest);\n  }\n\n  public warn(message: string, ...rest: (string | number | boolean | object)[]): void {\n    this.log('warn', message, ...rest);\n  }\n\n  public info(message: string, ...rest: (string | number | boolean | object)[]): void {\n    this.log('info', message, ...rest);\n  }\n\n  public debug(message: string, ...rest: (string | number | boolean | object)[]): void {\n    this.log('debug', message, ...rest);\n  }\n\n  public trace(message: string, ...rest: (string | number | boolean | object)[]): void {\n    this.log('trace', message, ...rest);\n  }\n}\n\nexport function createWinstonLogger(props?: LoggerProps): ILogger {\n  return new WinstonLogger(props);\n}\n"]}

package/package.json

@@ -0,0 +1,137 @@
+{
+  "name": "@ncfour-us/logging",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ncfour-us/logging.git"
+  },
+  "author": {
+    "name": "Tim Hahn",
+    "email": "hahntj@gmail.com",
+    "organization": false
+  },
+  "devDependencies": {
+    "@eslint/compat": "^2.1.0",
+    "@eslint/eslintrc": "^3.3.5",
+    "@eslint/js": "^9.39.4",
+    "@jest/globals": "^29.7.0",
+    "@ncfour-us/projen-utils": "^0.1.9",
+    "@stylistic/eslint-plugin": "^5.10.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^24",
+    "@typescript-eslint/eslint-plugin": "^8.59.4",
+    "@typescript-eslint/parser": "^8.59.4",
+    "commit-and-tag-version": "^12",
+    "constructs": "^10.0.0",
+    "eslint": "^9.39.4",
+    "eslint-import-resolver-typescript": "^3.10.1",
+    "eslint-plugin-import": "^2.32.0",
+    "globals": "^14.0.0",
+    "jest": "^29.7.0",
+    "jest-junit": "^17",
+    "jiti": "^2.7.0",
+    "prettier": "^3.8.3",
+    "projen": "^0.99.70",
+    "ts-jest": "^29.4.11",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.22.3",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "winston": "^3.19.0"
+  },
+  "engines": {
+    "node": ">= 24.0.0"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "pnpm",
+      "version": ">=10",
+      "onFail": "ignore"
+    }
+  },
+  "main": "lib/index.js",
+  "license": "MIT",
+  "version": "0.0.8",
+  "jest": {
+    "coverageProvider": "v8",
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.js$": "$1"
+    },
+    "transform": {
+      "^.+\\.(mt|t|cj|j)s$": [
+        "ts-jest",
+        {
+          "useESM": true,
+          "tsconfig": "tsconfig.dev.json"
+        }
+      ]
+    },
+    "testMatch": [
+      "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)",
+      "<rootDir>/@(projenrc)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(projenrc)/**/__tests__/**/*.ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ]
+  },
+  "types": "lib/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": "./lib/logger.js"
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.ts and run \"pnpm exec projen\".",
+  "scripts": {
+    "build": "projen build",
+    "bump": "projen bump",
+    "clobber": "projen clobber",
+    "compile": "projen compile",
+    "default": "projen default",
+    "eject": "projen eject",
+    "eslint": "projen eslint",
+    "package": "projen package",
+    "post-compile": "projen post-compile",
+    "post-upgrade": "projen post-upgrade",
+    "pre-compile": "projen pre-compile",
+    "publish:git": "projen publish:git",
+    "publish:local": "projen publish:local",
+    "publish:npm": "projen publish:npm",
+    "release": "projen release",
+    "test": "projen test",
+    "test:watch": "projen test:watch",
+    "unbump": "projen unbump",
+    "upgrade": "projen upgrade",
+    "watch": "projen watch",
+    "projen": "projen"
+  }
+}