@cenk1cenk2/oclif-common 6.3.29 → 6.4.0

package/dist/lib/locker/locker.module.js

@@ -0,0 +1,33 @@
+import { LoggerService } from "../logger/logger.service.js";
+import "../logger/index.js";
+import { FileSystemService } from "../fs/filesystem.service.js";
+import "../fs/index.js";
+import { ParserService } from "../parser/parser.service.js";
+import "../parser/index.js";
+import { LockerService } from "./locker.service.js";
+import { Module } from "@nestjs/common";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
+
+//#region src/lib/locker/locker.module.ts
+var _LockerModule;
+let LockerModule = _LockerModule = class LockerModule$1 {
+	static forFeature(options) {
+		const token = options.token ?? LockerService;
+		return {
+			module: _LockerModule,
+			providers: [{
+				provide: token,
+				useFactory: (logger, fs, parser) => new LockerService(logger, fs, parser, options),
+				inject: [
+					LoggerService,
+					FileSystemService,
+					ParserService
+				]
+			}]
+		};
+	}
+};
+LockerModule = _LockerModule = _decorate([Module({})], LockerModule);
+
+//#endregion
+export { LockerModule };

package/dist/lib/locker/locker.service.d.ts

@@ -0,0 +1,41 @@
+import { LoggerService } from "../logger/logger.service.js";
+import { FileSystemService } from "../fs/filesystem.service.js";
+import { ParserService } from "../parser/parser.service.js";
+import { LockData, LockableData, LockerServiceOptions, UnlockData } from "./locker.interface.js";
+import { OnModuleInit } from "@nestjs/common";
+import op from "object-path-immutable";
+
+//#region src/lib/locker/locker.service.d.ts
+declare class LockerService<LockFile extends LockableData = LockableData> implements OnModuleInit {
+  private readonly logger;
+  private readonly fs;
+  private readonly parser;
+  private readonly options;
+  readonly op: typeof op;
+  private toLock;
+  private toUnlock;
+  constructor(logger: LoggerService, fs: FileSystemService, parser: ParserService, options: LockerServiceOptions);
+  onModuleInit(): Promise<void>;
+  hasLock(): boolean;
+  hasUnlock(): boolean;
+  addLock<T extends LockableData = LockFile>(...data: LockData<T>[]): void;
+  addUnlock(...data: UnlockData[]): void;
+  applyLockAll(lock: LockFile): Promise<LockFile>;
+  lockAll(): Promise<void>;
+  applyUnlockAll(lock: LockFile): Promise<LockFile>;
+  unlockAll(): Promise<void>;
+  all(): Promise<void>;
+  applyAll(lock: LockFile): Promise<LockFile>;
+  applyLock<T extends LockableData = LockFile>(lock: LockFile, ...data: LockData<T>[]): Promise<LockFile>;
+  lock<T extends LockableData = LockFile>(...data: LockData<T>[]): Promise<LockFile>;
+  applyUnlock(lock: LockFile, ...data: UnlockData[]): Promise<LockFile>;
+  unlock(...data: UnlockData[]): Promise<LockFile | undefined>;
+  read(): Promise<LockFile>;
+  tryRead(): Promise<LockFile | undefined>;
+  tryRemove(): Promise<void>;
+  write(data: LockFile): Promise<void>;
+  private buildPath;
+  private normalizePath;
+}
+//#endregion
+export { LockerService };

package/dist/lib/locker/locker.service.js

@@ -0,0 +1,170 @@
+import { LoggerService } from "../logger/logger.service.js";
+import "../logger/index.js";
+import { FileSystemService } from "../fs/filesystem.service.js";
+import "../fs/index.js";
+import { ParserService } from "../parser/parser.service.js";
+import { merge } from "../../utils/merge.js";
+import "../../utils/index.js";
+import "../parser/index.js";
+import { Injectable } from "@nestjs/common";
+import op from "object-path-immutable";
+import _decorateMetadata from "@oxc-project/runtime/helpers/decorateMetadata";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
+
+//#region src/lib/locker/locker.service.ts
+var _ref, _ref2, _ref3;
+let LockerService = class LockerService$1 {
+	constructor(logger, fs, parser, options) {
+		this.logger = logger;
+		this.fs = fs;
+		this.parser = parser;
+		this.options = options;
+		this.op = op;
+		this.toLock = [];
+		this.toUnlock = [];
+	}
+	async onModuleInit() {
+		this.logger.setup(this.constructor.name);
+	}
+	hasLock() {
+		return this.toLock.length > 0;
+	}
+	hasUnlock() {
+		return this.toUnlock.length > 0;
+	}
+	addLock(...data) {
+		this.toLock.push(...data);
+	}
+	addUnlock(...data) {
+		this.toUnlock.push(...data);
+	}
+	async applyLockAll(lock) {
+		if (this.hasLock()) return this.applyLock(lock, ...this.toLock);
+		return lock;
+	}
+	async lockAll() {
+		if (this.hasLock()) {
+			await this.lock(...this.toLock);
+			this.toLock = [];
+		}
+	}
+	async applyUnlockAll(lock) {
+		if (this.hasUnlock()) return this.applyUnlock(lock, ...this.toUnlock);
+		return lock;
+	}
+	async unlockAll() {
+		if (this.hasUnlock()) {
+			await this.unlock(...this.toUnlock);
+			this.toUnlock = [];
+		}
+	}
+	async all() {
+		await this.unlockAll();
+		await this.lockAll();
+	}
+	async applyAll(lock) {
+		lock = await this.applyUnlockAll(lock);
+		lock = await this.applyLockAll(lock);
+		return lock;
+	}
+	async applyLock(lock, ...data) {
+		data.forEach((d) => {
+			if (d?.enabled === false) return;
+			else if (!d?.data || Array.isArray(d?.data) && d.data.length === 0 || typeof d?.data === "object" && Object.keys(d.data).length === 0) return;
+			const path = this.buildPath(d);
+			if (d?.merge) {
+				let parsed;
+				if (typeof d.data === "object") parsed = merge(d.merge, this.op.get(lock, path, Array.isArray(d.data) ? [] : {}), d.data);
+				else {
+					this.logger.warn("\"%s\" path with type \"%s\" is not mergeable.", path, typeof d.data);
+					parsed = d.data;
+				}
+				lock = this.op.set(lock, path, parsed);
+				this.logger.verbose("Merge lock: %s -> %o", path, d.data);
+				return;
+			}
+			lock = this.op.set(lock, path, d.data);
+			this.logger.verbose("Override lock: %s -> %o", path, d.data);
+		});
+		return lock;
+	}
+	async lock(...data) {
+		const lock = await this.applyLock(await this.tryRead() ?? {}, ...data);
+		await this.write(lock);
+		return lock;
+	}
+	async applyUnlock(lock, ...data) {
+		if (data.length > 0) {
+			data.forEach((d) => {
+				if (d?.enabled === false) return;
+				const path = this.buildPath(d);
+				lock = op.del(lock, path);
+				this.logger.verbose("Unlocked: %s", path);
+				for (let i = path.length - 1; i >= 0; i--) {
+					const parentPath = path.slice(0, i);
+					const parent = this.op.get(lock, parentPath);
+					if (!parent || Array.isArray(parent) && parent.length === 0 || typeof parent === "object" && Object.keys(parent).length === 0) {
+						this.logger.verbose("Unlocked parent: %s -> %s", path, parentPath);
+						lock = op.del(lock, parentPath);
+					} else break;
+				}
+			});
+			return lock;
+		}
+		lock = op.del(lock, this.options.root);
+		this.logger.verbose("Unlocked module: %s", this.options.root);
+		return lock;
+	}
+	async unlock(...data) {
+		const state = await this.tryRead();
+		if (!state) {
+			this.logger.verbose("Lock file not found. Nothing to unlock.");
+			return;
+		}
+		const lock = await this.applyUnlock(state, ...data);
+		await this.write(lock);
+		return lock;
+	}
+	async read() {
+		return this.parser.fetch(this.options.parser).parse(await this.fs.read(this.options.file));
+	}
+	async tryRead() {
+		const lock = await this.fs.read(this.options.file).catch((err) => {
+			this.logger.trace("Can not read lockfile: %s -> %s", this.options.file, err.message);
+		});
+		if (!lock) return;
+		return this.parser.fetch(this.options.parser).parse(lock);
+	}
+	async tryRemove() {
+		return this.fs.remove(this.options.file).then(() => {
+			this.logger.trace("Removed lockfile: %s", this.options.file);
+		}).catch((err) => {
+			this.logger.trace("Can not remove lockfile: %s -> %s", this.options.file, err.message);
+		});
+	}
+	async write(data) {
+		if (!data || Array.isArray(data) && data.length === 0 || typeof data === "object" && Object.keys(data).length === 0) {
+			this.logger.trace("Trying to write empty lock file, deleting it instead: %s", this.options.file);
+			return this.fs.remove(this.options.file);
+		}
+		return this.fs.write(this.options.file, this.parser.fetch(this.options.parser).stringify(data));
+	}
+	buildPath(d) {
+		if (d?.root !== true && this.options.root?.length) return [...this.options.root, ...this.normalizePath(d.path)];
+		return this.normalizePath(d.path);
+	}
+	normalizePath(path) {
+		if (Array.isArray(path)) return path.map((p) => p.toString());
+		else if (typeof path === "string") return path.split(".");
+		return [];
+	}
+};
+LockerService = _decorate([Injectable(), _decorateMetadata("design:paramtypes", [
+	typeof (_ref = typeof LoggerService !== "undefined" && LoggerService) === "function" ? _ref : Object,
+	typeof (_ref2 = typeof FileSystemService !== "undefined" && FileSystemService) === "function" ? _ref2 : Object,
+	typeof (_ref3 = typeof ParserService !== "undefined" && ParserService) === "function" ? _ref3 : Object,
+	Object
+])], LockerService);
+
+//#endregion
+export { LockerService };

package/dist/lib/logger/index.js

@@ -0,0 +1,6 @@
+import { pipeProcessThroughListr } from "./pipe/pipe-process-to-listr.js";
+import { LogFieldStatus, LogLevels } from "./logger.constants.js";
+import { pipeProcessToLogger } from "./pipe/pipe-process-to-logger.js";
+import { WinstonService } from "./winston.service.js";
+import { LoggerService } from "./logger.service.js";
+import { LoggerModule } from "./logger.module.js";

package/dist/lib/logger/logger.constants.d.ts

@@ -0,0 +1,21 @@
+//#region src/lib/logger/logger.constants.d.ts
+declare enum LogLevels {
+  SILENT = "SILENT",
+  DIRECT = "DIRECT",
+  FATAL = "FATAL",
+  ERROR = "ERROR",
+  WARN = "WARN",
+  INFO = "INFO",
+  VERBOSE = "VERBOSE",
+  DEBUG = "DEBUG",
+  TRACE = "TRACE",
+}
+declare enum LogFieldStatus {
+  RUN = "run",
+  END = "end",
+  STAGE = "stage",
+  EXIT = "exit",
+  TERMINATE = "terminate",
+}
+//#endregion
+export { LogFieldStatus, LogLevels };

package/dist/lib/logger/logger.constants.js

@@ -0,0 +1,24 @@
+//#region src/lib/logger/logger.constants.ts
+let LogLevels = /* @__PURE__ */ function(LogLevels$1) {
+	LogLevels$1["SILENT"] = "SILENT";
+	LogLevels$1["DIRECT"] = "DIRECT";
+	LogLevels$1["FATAL"] = "FATAL";
+	LogLevels$1["ERROR"] = "ERROR";
+	LogLevels$1["WARN"] = "WARN";
+	LogLevels$1["INFO"] = "INFO";
+	LogLevels$1["VERBOSE"] = "VERBOSE";
+	LogLevels$1["DEBUG"] = "DEBUG";
+	LogLevels$1["TRACE"] = "TRACE";
+	return LogLevels$1;
+}({});
+let LogFieldStatus = /* @__PURE__ */ function(LogFieldStatus$1) {
+	LogFieldStatus$1["RUN"] = "run";
+	LogFieldStatus$1["END"] = "end";
+	LogFieldStatus$1["STAGE"] = "stage";
+	LogFieldStatus$1["EXIT"] = "exit";
+	LogFieldStatus$1["TERMINATE"] = "terminate";
+	return LogFieldStatus$1;
+}({});
+
+//#endregion
+export { LogFieldStatus, LogLevels };

package/dist/lib/logger/logger.interface.d.ts

@@ -0,0 +1,13 @@
+import { LogLevels } from "./logger.constants.js";
+import { LeveledLogMethod, Logger } from "winston";
+
+//#region src/lib/logger/logger.interface.d.ts
+interface LoggerFormat {
+  level: LogLevels;
+  message: string;
+  context: string;
+  status: string;
+}
+type Winston = Logger & Record<keyof typeof LogLevels, LeveledLogMethod>;
+//#endregion
+export { LoggerFormat, Winston };

package/dist/lib/logger/logger.module.d.ts

@@ -0,0 +1,4 @@
+//#region src/lib/logger/logger.module.d.ts
+declare class LoggerModule {}
+//#endregion
+export { LoggerModule };

package/dist/lib/logger/logger.module.js

@@ -0,0 +1,17 @@
+import { WinstonService } from "./winston.service.js";
+import { LoggerService } from "./logger.service.js";
+import { ConfigModule } from "../config/config.module.js";
+import "../config/index.js";
+import { Global, Module } from "@nestjs/common";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
+
+//#region src/lib/logger/logger.module.ts
+let LoggerModule = class LoggerModule$1 {};
+LoggerModule = _decorate([Global(), Module({
+	imports: [ConfigModule],
+	providers: [WinstonService, LoggerService],
+	exports: [LoggerService]
+})], LoggerModule);
+
+//#endregion
+export { LoggerModule };

package/dist/lib/logger/logger.service.d.ts

@@ -0,0 +1,31 @@
+import { LogLevels } from "./logger.constants.js";
+import { WinstonService } from "./winston.service.js";
+import { splat } from "listr2";
+
+//#region src/lib/logger/logger.service.d.ts
+
+/**
+ * A general logger for the the CLI applications.
+ */
+declare class LoggerService {
+  private readonly winston;
+  context: string;
+  constructor(winston: WinstonService);
+  setup(context: string): LoggerService;
+  log(level: LogLevels, data: string | Buffer, ...args: any): void;
+  direct(data: string | Buffer, ...args: any): void;
+  fatal(data: string | Buffer, ...args: any): void;
+  error(data: string | Buffer, ...args: any): void;
+  warn(data: string | Buffer, ...args: any): void;
+  info(data: string | Buffer, ...args: any): void;
+  verbose(data: string | Buffer, ...args: any): void;
+  debug(data: string | Buffer, ...args: any): void;
+  trace(data: string | Buffer, ...args: any): void;
+  run(data: string | Buffer, ...args: any): void;
+  end(data: string | Buffer, ...args: any): void;
+  stage(data: string | Buffer, ...args: any): void;
+  splat(...args: Parameters<typeof splat>): ReturnType<typeof splat>;
+  private parseMessage;
+}
+//#endregion
+export { LoggerService };

package/dist/lib/logger/logger.service.js

@@ -0,0 +1,70 @@
+import { LogFieldStatus, LogLevels } from "./logger.constants.js";
+import { WinstonService } from "./winston.service.js";
+import { Injectable, Scope } from "@nestjs/common";
+import { splat } from "listr2";
+import _decorateMetadata from "@oxc-project/runtime/helpers/decorateMetadata";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
+
+//#region src/lib/logger/logger.service.ts
+var _ref;
+let LoggerService = class LoggerService$1 {
+	constructor(winston) {
+		this.winston = winston;
+	}
+	setup(context) {
+		this.context = context;
+		return this;
+	}
+	log(level, data, ...args) {
+		return this.parseMessage(level, data, args);
+	}
+	direct(data, ...args) {
+		return this.parseMessage(LogLevels.DIRECT, data, args);
+	}
+	fatal(data, ...args) {
+		return this.parseMessage(LogLevels.FATAL, data, args);
+	}
+	error(data, ...args) {
+		return this.parseMessage(LogLevels.ERROR, data, args);
+	}
+	warn(data, ...args) {
+		return this.parseMessage(LogLevels.WARN, data, args);
+	}
+	info(data, ...args) {
+		return this.parseMessage(LogLevels.INFO, data, args);
+	}
+	verbose(data, ...args) {
+		return this.parseMessage(LogLevels.VERBOSE, data, args);
+	}
+	debug(data, ...args) {
+		return this.parseMessage(LogLevels.DEBUG, data, args);
+	}
+	trace(data, ...args) {
+		return this.parseMessage(LogLevels.TRACE, data, args);
+	}
+	run(data, ...args) {
+		return this.parseMessage(LogLevels.INFO, data, args, { status: LogFieldStatus.RUN });
+	}
+	end(data, ...args) {
+		return this.parseMessage(LogLevels.INFO, data, args, { status: LogFieldStatus.END });
+	}
+	stage(data, ...args) {
+		return this.parseMessage(LogLevels.TRACE, data, args, { status: LogFieldStatus.STAGE });
+	}
+	splat(...args) {
+		const message = args.shift();
+		if (typeof message === "undefined") return "";
+		if (args.length === 0) return message;
+		return splat(message, args);
+	}
+	parseMessage(level, data, args, format) {
+		this.winston.instance.log(level, data.toString(), ...args ?? [], {
+			context: this.context,
+			...format ?? {}
+		});
+	}
+};
+LoggerService = _decorate([Injectable({ scope: Scope.TRANSIENT }), _decorateMetadata("design:paramtypes", [typeof (_ref = typeof WinstonService !== "undefined" && WinstonService) === "function" ? _ref : Object])], LoggerService);
+
+//#endregion
+export { LoggerService };

package/dist/lib/logger/pipe/pipe-process-to-listr.d.ts

@@ -0,0 +1,7 @@
+import { ListrTaskWrapper } from "listr2";
+import { ChildProcess } from "child_process";
+
+//#region src/lib/logger/pipe/pipe-process-to-listr.d.ts
+declare function pipeProcessThroughListr(task: ListrTaskWrapper<any, any, any>, instance: ChildProcess): ChildProcess;
+//#endregion
+export { pipeProcessThroughListr };

package/dist/lib/logger/pipe/pipe-process-to-listr.js

@@ -0,0 +1,9 @@
+//#region src/lib/logger/pipe/pipe-process-to-listr.ts
+function pipeProcessThroughListr(task, instance) {
+	instance.stdout.pipe(task.stdout());
+	instance.stderr.pipe(task.stdout());
+	return instance;
+}
+
+//#endregion
+export { pipeProcessThroughListr };

package/dist/lib/logger/pipe/pipe-process-to-logger.d.ts

@@ -0,0 +1,12 @@
+import { PipeProcessToLoggerOptions } from "./pipe-process-to-logger.interface.js";
+import { LoggerService } from "../logger.service.js";
+import { ChildProcess } from "child_process";
+
+//#region src/lib/logger/pipe/pipe-process-to-logger.d.ts
+
+/**
+ * Given the instance it will pipe process output through the logger to append prefixes such as the application name.
+ */
+declare function pipeProcessToLogger(logger: LoggerService, instance: ChildProcess, options?: PipeProcessToLoggerOptions): ChildProcess;
+//#endregion
+export { pipeProcessToLogger };

package/dist/lib/logger/pipe/pipe-process-to-logger.interface.d.ts

@@ -0,0 +1,19 @@
+import { LogLevels } from "../logger.constants.js";
+
+//#region src/lib/logger/pipe/pipe-process-to-logger.interface.d.ts
+interface PipeProcessToLoggerOptions {
+  /** Will log the command when the process starts. */
+  start?: LogLevels;
+  /** Will log the command when the process ends. */
+  end?: LogLevels;
+  /** enable/disable stdout */
+  stdout?: LogLevels;
+  /** enable/disable stderrr */
+  stderr?: LogLevels;
+  /** will callback on error in the instance */
+  callback?: (error?: Error) => void;
+  /** context for logger */
+  context?: string;
+}
+//#endregion
+export { PipeProcessToLoggerOptions };

package/dist/lib/logger/pipe/pipe-process-to-logger.js

@@ -0,0 +1,54 @@
+import { LogLevels } from "../logger.constants.js";
+import { Writable } from "stream";
+
+//#region src/lib/logger/pipe/pipe-process-to-logger.ts
+/**
+* Given the instance it will pipe process output through the logger to append prefixes such as the application name.
+*/
+function pipeProcessToLogger(logger, instance, options) {
+	options = {
+		start: LogLevels.INFO,
+		end: LogLevels.INFO,
+		stdout: LogLevels.INFO,
+		stderr: LogLevels.WARN,
+		...options
+	};
+	if (options.start) logger.run(instance.spawnargs.join(" "), {
+		level: options.start,
+		context: options.context
+	});
+	if (instance.stdout) {
+		const writable = new Writable();
+		writable.write = (chunk) => {
+			logger.log(options.stdout, chunk, { context: options.context });
+			return true;
+		};
+		instance.stdout.pipe(writable);
+	}
+	if (instance.stderr) {
+		const writable = new Writable();
+		writable.write = (chunk) => {
+			logger.log(options.stderr, chunk, { context: options.context });
+			return true;
+		};
+		instance.stderr.pipe(writable);
+	}
+	instance.on("exit", (code, signal) => {
+		const message = `Process ended with code ${code}${signal ? ` and signal ${signal}` : ""}.`;
+		logger.debug(message, { context: options.context });
+		if (options.end) logger.end(instance.spawnargs.join(" "), {
+			level: options.end,
+			context: options.context
+		});
+		if (options?.callback) options.callback();
+	});
+	instance.on("error", (error) => {
+		logger.fatal(error.message, { context: options.context });
+		logger.debug(error.stack, { context: options.context });
+		if (options?.callback) options.callback(error);
+	});
+	return instance;
+}
+
+//#endregion
+export { pipeProcessToLogger };

package/dist/lib/logger/winston.service.d.ts

@@ -0,0 +1,15 @@
+import { ConfigModuleOptions } from "../config/config.interface.js";
+import { Winston } from "./logger.interface.js";
+import { OnModuleInit } from "@nestjs/common";
+
+//#region src/lib/logger/winston.service.d.ts
+declare class WinstonService implements OnModuleInit {
+  private readonly options;
+  instance: Winston;
+  constructor(options: ConfigModuleOptions);
+  onModuleInit(): void;
+  private initiateLogger;
+  private logColoring;
+}
+//#endregion
+export { WinstonService };

package/dist/lib/logger/winston.service.js

@@ -0,0 +1,91 @@
+import { TOKEN_CONFIG_MODULE_OPTIONS } from "../config/config.constants.js";
+import { LogLevels } from "./logger.constants.js";
+import { Inject, Injectable } from "@nestjs/common";
+import { color, figures } from "listr2";
+import { EOL } from "os";
+import winston, { format, transports } from "winston";
+import _decorateMetadata from "@oxc-project/runtime/helpers/decorateMetadata";
+import _decorateParam from "@oxc-project/runtime/helpers/decorateParam";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
+
+//#region src/lib/logger/winston.service.ts
+let WinstonService = class WinstonService$1 {
+	constructor(options) {
+		this.options = options;
+	}
+	onModuleInit() {
+		this.instance = this.initiateLogger();
+	}
+	initiateLogger() {
+		const logFormat = format.printf((({ level, message, context, status }) => {
+			return message.split(EOL).filter((msg) => !msg || msg.trim() !== "").map((msg) => {
+				return this.logColoring({
+					level,
+					message: msg,
+					context,
+					status
+				});
+			}).join(EOL);
+		}));
+		const logger = winston.createLogger({
+			level: this.options.config.logLevel,
+			format: format.combine(format.splat(), format.json({ space: 2 }), format.prettyPrint(), logFormat),
+			levels: Object.fromEntries(Object.values(LogLevels).map((level, i) => {
+				return [level, i];
+			})),
+			silent: this.options.config.logLevel === LogLevels.SILENT || this.options.config.isJson,
+			transports: [new transports.Console({ stderrLevels: [LogLevels.FATAL, LogLevels.ERROR] })]
+		});
+		logger.log(LogLevels.TRACE, "Initiated new winston with level: %s", this.options.config.logLevel, { context: this.constructor.name });
+		return logger;
+	}
+	logColoring({ level, message, context, status }) {
+		let icon;
+		let coloring = (input) => {
+			return input;
+		};
+		let msgColoring = (input) => {
+			return input;
+		};
+		switch (level) {
+			case LogLevels.DIRECT: return message;
+			case LogLevels.FATAL:
+				coloring = color.red;
+				msgColoring = color.red;
+				break;
+			case LogLevels.ERROR:
+				coloring = color.red;
+				icon = figures.cross;
+				break;
+			case LogLevels.WARN:
+				coloring = color.yellow;
+				icon = figures.warning;
+				break;
+			case LogLevels.INFO:
+				coloring = color.green;
+				icon = figures.pointerSmall;
+				break;
+			case LogLevels.VERBOSE:
+				coloring = color.dim;
+				break;
+			case LogLevels.DEBUG:
+				coloring = color.cyan;
+				msgColoring = color.dim;
+				break;
+			case LogLevels.TRACE:
+				coloring = color.magenta;
+				msgColoring = color.dim;
+				break;
+		}
+		if (!icon) icon = `[${level.at(0).toUpperCase()}]`;
+		return `${coloring(icon)}${context ? " " + coloring(`[${context}]`) : ""}${status ? " " + coloring(`[${status}]`) : ""} ${msgColoring(message)}`;
+	}
+};
+WinstonService = _decorate([
+	Injectable(),
+	_decorateMetadata("design:paramtypes", [Object]),
+	_decorateParam(0, Inject(TOKEN_CONFIG_MODULE_OPTIONS))
+], WinstonService);
+
+//#endregion
+export { WinstonService };

package/dist/lib/logo/index.js

@@ -0,0 +1,3 @@
+import { TOKEN_LOGO_GENERATOR } from "./logo.constants.js";
+import { LogoService } from "./logo.service.js";
+import { LogoModule } from "./logo.module.js";

package/dist/lib/logo/logo.constants.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken } from "@nestjs/common";
+
+//#region src/lib/logo/logo.constants.d.ts
+declare const TOKEN_LOGO_GENERATOR: InjectionToken;
+//#endregion
+export { TOKEN_LOGO_GENERATOR };

package/dist/lib/logo/logo.constants.js

@@ -0,0 +1,5 @@
+//#region src/lib/logo/logo.constants.ts
+const TOKEN_LOGO_GENERATOR = Symbol("TOKEN_LOGO_GENERATOR");
+
+//#endregion
+export { TOKEN_LOGO_GENERATOR };