@cenk1cenk2/oclif-common 6.3.30 → 6.4.0

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

@@ -0,0 +1,6 @@
+import { LogoService } from "./logo.service.js";
+
+//#region src/lib/logo/logo.interface.d.ts
+type LogoGeneratorFn = (this: LogoService) => void;
+//#endregion
+export { LogoGeneratorFn };

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

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

package/dist/lib/logo/logo.module.js

@@ -0,0 +1,13 @@
+import { LogoService } from "./logo.service.js";
+import { Module } from "@nestjs/common";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
+
+//#region src/lib/logo/logo.module.ts
+let LogoModule = class LogoModule$1 {};
+LogoModule = _decorate([Module({
+	providers: [LogoService],
+	exports: [LogoService]
+})], LogoModule);
+
+//#endregion
+export { LogoModule };

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

@@ -0,0 +1,17 @@
+import { ConfigService } from "../config/config.service.js";
+import { OnModuleInit } from "@nestjs/common";
+import { ModuleRef } from "@nestjs/core";
+
+//#region src/lib/logo/logo.service.d.ts
+declare class LogoService implements OnModuleInit {
+  readonly cs: ConfigService;
+  private readonly moduleRef;
+  private generator;
+  constructor(cs: ConfigService, moduleRef: ModuleRef);
+  onModuleInit(): Promise<void>;
+  generate(): void;
+  shouldBeSilent(): boolean;
+  write(...data: string[]): void;
+}
+//#endregion
+export { LogoService };

package/dist/lib/logo/logo.service.js

@@ -0,0 +1,42 @@
+import { ConfigService } from "../config/config.service.js";
+import "../config/index.js";
+import { TOKEN_LOGO_GENERATOR } from "./logo.constants.js";
+import { Injectable } from "@nestjs/common";
+import { EOL } from "os";
+import _decorateMetadata from "@oxc-project/runtime/helpers/decorateMetadata";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
+import { ModuleRef } from "@nestjs/core";
+
+//#region src/lib/logo/logo.service.ts
+var _ref, _ref2;
+let LogoService = class LogoService$1 {
+	constructor(cs, moduleRef) {
+		this.cs = cs;
+		this.moduleRef = moduleRef;
+	}
+	async onModuleInit() {
+		try {
+			this.generator = this.moduleRef.get(TOKEN_LOGO_GENERATOR, { strict: false });
+		} catch {
+			this.generator = function() {
+				if (this.shouldBeSilent()) return;
+				const logo = this.cs.oclif.name + " v" + this.cs.oclif.version;
+				this.write(logo);
+				this.write("-".repeat(logo.length));
+			};
+		}
+	}
+	generate() {
+		return this.generator.call(this);
+	}
+	shouldBeSilent() {
+		return this.cs.isJson || this.cs.isSilent;
+	}
+	write(...data) {
+		process.stdout.write(data.join(" ") + EOL);
+	}
+};
+LogoService = _decorate([Injectable(), _decorateMetadata("design:paramtypes", [typeof (_ref = typeof ConfigService !== "undefined" && ConfigService) === "function" ? _ref : Object, typeof (_ref2 = typeof ModuleRef !== "undefined" && ModuleRef) === "function" ? _ref2 : Object])], LogoService);
+
+//#endregion
+export { LogoService };

package/dist/lib/parser/fts/env-parser.service.d.ts

@@ -0,0 +1,16 @@
+import { GenericParser } from "../parser.interface.js";
+import { LoggerService } from "../../logger/logger.service.js";
+import { OnModuleInit } from "@nestjs/common";
+
+//#region src/lib/parser/fts/env-parser.service.d.ts
+declare class EnvironmentVariableParser implements GenericParser, OnModuleInit {
+  private readonly logger;
+  readonly extensions: string[];
+  private readonly LINE;
+  constructor(logger: LoggerService);
+  onModuleInit(): Promise<void>;
+  parse<T = unknown>(data: string | Buffer): T;
+  stringify<T = any>(data: T): string;
+}
+//#endregion
+export { EnvironmentVariableParser };

package/dist/lib/parser/fts/env-parser.service.js

@@ -0,0 +1,42 @@
+import { LoggerService } from "../../logger/logger.service.js";
+import "../../logger/index.js";
+import { Injectable } from "@nestjs/common";
+import { EOL } from "os";
+import _decorateMetadata from "@oxc-project/runtime/helpers/decorateMetadata";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
+
+//#region src/lib/parser/fts/env-parser.service.ts
+var _ref;
+let EnvironmentVariableParser = class EnvironmentVariableParser$1 {
+	constructor(logger) {
+		this.logger = logger;
+		this.extensions = ["env"];
+		this.LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+	}
+	async onModuleInit() {
+		this.logger.setup(this.constructor.name);
+	}
+	parse(data) {
+		try {
+			return data.toString().split(EOL).reduce((o, line) => {
+				const match = this.LINE.exec(line);
+				const key = match[1];
+				const value = match[2] ?? "";
+				return {
+					...o,
+					[key]: value
+				};
+			}, {});
+		} catch (e) {
+			this.logger.trace("Error during parsing environment file: %s", e.message);
+			throw e;
+		}
+	}
+	stringify(data) {
+		return Object.entries(data).map(([k, v]) => `${k}=${v}`).join(EOL) + EOL;
+	}
+};
+EnvironmentVariableParser = _decorate([Injectable(), _decorateMetadata("design:paramtypes", [typeof (_ref = typeof LoggerService !== "undefined" && LoggerService) === "function" ? _ref : Object])], EnvironmentVariableParser);
+
+//#endregion
+export { EnvironmentVariableParser };

package/dist/lib/parser/fts/index.js

@@ -0,0 +1,3 @@
+import { EnvironmentVariableParser } from "./env-parser.service.js";
+import { JsonParser } from "./json-parser.service.js";
+import { YamlParser } from "./yaml-parser.service.js";

package/dist/lib/parser/fts/json-parser.service.d.ts

@@ -0,0 +1,15 @@
+import { GenericParser } from "../parser.interface.js";
+import { LoggerService } from "../../logger/logger.service.js";
+import { OnModuleInit } from "@nestjs/common";
+
+//#region src/lib/parser/fts/json-parser.service.d.ts
+declare class JsonParser implements GenericParser, OnModuleInit {
+  private readonly logger;
+  readonly extensions: string[];
+  constructor(logger: LoggerService);
+  onModuleInit(): Promise<void>;
+  parse<T = unknown>(data: string | Buffer): T;
+  stringify<T = any>(data: T): string;
+}
+//#endregion
+export { JsonParser };

package/dist/lib/parser/fts/json-parser.service.js

@@ -0,0 +1,32 @@
+import { LoggerService } from "../../logger/logger.service.js";
+import "../../logger/index.js";
+import { Injectable } from "@nestjs/common";
+import _decorateMetadata from "@oxc-project/runtime/helpers/decorateMetadata";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
+
+//#region src/lib/parser/fts/json-parser.service.ts
+var _ref;
+let JsonParser = class JsonParser$1 {
+	constructor(logger) {
+		this.logger = logger;
+		this.extensions = ["json"];
+	}
+	async onModuleInit() {
+		this.logger.setup(this.constructor.name);
+	}
+	parse(data) {
+		try {
+			return JSON.parse(data.toString());
+		} catch (e) {
+			this.logger.trace("Error during parsing JSON file: %s", e.message);
+			throw e;
+		}
+	}
+	stringify(data) {
+		return JSON.stringify(data, null, 2);
+	}
+};
+JsonParser = _decorate([Injectable(), _decorateMetadata("design:paramtypes", [typeof (_ref = typeof LoggerService !== "undefined" && LoggerService) === "function" ? _ref : Object])], JsonParser);
+
+//#endregion
+export { JsonParser };

package/dist/lib/parser/fts/yaml-parser.service.d.ts

@@ -0,0 +1,15 @@
+import { GenericParser } from "../parser.interface.js";
+import { LoggerService } from "../../logger/logger.service.js";
+import { OnModuleInit } from "@nestjs/common";
+
+//#region src/lib/parser/fts/yaml-parser.service.d.ts
+declare class YamlParser implements GenericParser, OnModuleInit {
+  private readonly logger;
+  readonly extensions: string[];
+  constructor(logger: LoggerService);
+  onModuleInit(): Promise<void>;
+  parse<T = unknown>(data: string | Buffer): T;
+  stringify<T = any>(data: T): string;
+}
+//#endregion
+export { YamlParser };

package/dist/lib/parser/fts/yaml-parser.service.js

@@ -0,0 +1,33 @@
+import { LoggerService } from "../../logger/logger.service.js";
+import "../../logger/index.js";
+import { Injectable } from "@nestjs/common";
+import _decorateMetadata from "@oxc-project/runtime/helpers/decorateMetadata";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
+import { parse, stringify } from "yaml";
+
+//#region src/lib/parser/fts/yaml-parser.service.ts
+var _ref;
+let YamlParser = class YamlParser$1 {
+	constructor(logger) {
+		this.logger = logger;
+		this.extensions = ["yaml", "yml"];
+	}
+	async onModuleInit() {
+		this.logger.setup(this.constructor.name);
+	}
+	parse(data) {
+		try {
+			return parse(data.toString());
+		} catch (e) {
+			this.logger.trace("Error during parsing YAML file: %s", e.message);
+			throw e;
+		}
+	}
+	stringify(data) {
+		return stringify(data, { prettyErrors: true });
+	}
+};
+YamlParser = _decorate([Injectable(), _decorateMetadata("design:paramtypes", [typeof (_ref = typeof LoggerService !== "undefined" && LoggerService) === "function" ? _ref : Object])], YamlParser);
+
+//#endregion
+export { YamlParser };

package/dist/lib/parser/index.js

@@ -0,0 +1,6 @@
+import { ParserService } from "./parser.service.js";
+import { ParserModule } from "./parser.module.js";
+import { EnvironmentVariableParser } from "./fts/env-parser.service.js";
+import { JsonParser } from "./fts/json-parser.service.js";
+import { YamlParser } from "./fts/yaml-parser.service.js";
+import "./fts/index.js";

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

@@ -0,0 +1,8 @@
+//#region src/lib/parser/parser.interface.d.ts
+declare class GenericParser {
+  readonly extensions: string[];
+  parse<T = unknown>(data: string | Buffer): T;
+  stringify<T = any>(data: T): string;
+}
+//#endregion
+export { GenericParser };

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

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

package/dist/lib/parser/parser.module.js

@@ -0,0 +1,16 @@
+import { FilesystemModule } from "../fs/filesystem.module.js";
+import "../fs/index.js";
+import { ParserService } from "./parser.service.js";
+import { Global, Module } from "@nestjs/common";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
+
+//#region src/lib/parser/parser.module.ts
+let ParserModule = class ParserModule$1 {};
+ParserModule = _decorate([Global(), Module({
+	imports: [FilesystemModule],
+	providers: [ParserService],
+	exports: [ParserService]
+})], ParserModule);
+
+//#endregion
+export { ParserModule };

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

@@ -0,0 +1,29 @@
+import { ClassType } from "../../interfaces/class.interface.js";
+import { GenericParser } from "./parser.interface.js";
+import { LoggerService } from "../logger/logger.service.js";
+import { FileSystemService } from "../fs/filesystem.service.js";
+import { LockableData } from "../locker/locker.interface.js";
+import { OnModuleInit } from "@nestjs/common";
+import { ModuleRef } from "@nestjs/core";
+
+//#region src/lib/parser/parser.service.d.ts
+declare class ParserService implements OnModuleInit {
+  private moduleRef;
+  private fs;
+  private readonly logger;
+  private readonly instances;
+  constructor(moduleRef: ModuleRef, fs: FileSystemService, logger: LoggerService);
+  onModuleInit(): Promise<void>;
+  byFt(file: string): GenericParser;
+  fetch<T extends GenericParser>(Parser: ClassType<T>): T;
+  inject<T extends GenericParser>(Parser: ClassType<T>): Promise<T>;
+  register(...parsers: ClassType<GenericParser>[]): Promise<void>;
+  read<T = unknown>(file: string): Promise<T>;
+  write<T = LockableData>(file: string, data: T): Promise<void>;
+  parse<T = unknown>(file: string, data: string | Buffer): T;
+  parseWith<T = unknown>(Parser: ClassType<GenericParser>, data: string | Buffer): T;
+  stringify<T = any>(file: string, data: T): string;
+  stringifyWith<T = any>(Parser: ClassType<GenericParser>, data: T): string;
+}
+//#endregion
+export { ParserService };

package/dist/lib/parser/parser.service.js

@@ -0,0 +1,76 @@
+import { LoggerService } from "../logger/logger.service.js";
+import "../logger/index.js";
+import { FileSystemService } from "../fs/filesystem.service.js";
+import "../fs/index.js";
+import { Injectable } from "@nestjs/common";
+import _decorateMetadata from "@oxc-project/runtime/helpers/decorateMetadata";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
+import { ModuleRef } from "@nestjs/core";
+
+//#region src/lib/parser/parser.service.ts
+var _ref, _ref2, _ref3;
+let ParserService = class ParserService$1 {
+	constructor(moduleRef, fs, logger) {
+		this.moduleRef = moduleRef;
+		this.fs = fs;
+		this.logger = logger;
+		this.instances = [];
+	}
+	async onModuleInit() {
+		this.logger.setup(this.constructor.name);
+	}
+	byFt(file) {
+		const ext = (file.includes(".") ? this.fs.extname(file) : file).replace(/^\./, "");
+		const Parser = this.instances.find((parser) => parser.extensions.includes(ext));
+		if (!Parser) throw new Error(`Parser for the extension is not configured: ${ext}`);
+		return Parser;
+	}
+	fetch(Parser) {
+		const parser = this.instances.find((instance) => instance instanceof Parser);
+		if (!parser) throw new Error(`Specified parser has not been initiated: ${Parser.name}`);
+		return parser;
+	}
+	async inject(Parser) {
+		const parser = await this.moduleRef.create(Parser);
+		this.instances.push(parser);
+		return parser;
+	}
+	async register(...parsers) {
+		await Promise.all(parsers.map(async (parser) => this.inject(parser)));
+		this.logger.trace("Registered parsers: %o", parsers.map((p) => p.name));
+	}
+	async read(file) {
+		return this.parse(file, await this.fs.read(file));
+	}
+	async write(file, data) {
+		return this.fs.write(file, this.stringify(file, data));
+	}
+	parse(file, data) {
+		const parser = this.byFt(file);
+		this.logger.trace("Parsing file: %s -> %s", file, parser.constructor.name);
+		return parser.parse(data);
+	}
+	parseWith(Parser, data) {
+		const parser = this.fetch(Parser);
+		this.logger.trace("Parsing data with: %s", parser.constructor.name);
+		return parser.parse(data);
+	}
+	stringify(file, data) {
+		const parser = this.byFt(file);
+		this.logger.trace("Stringifying file: %s -> %s", file, parser.constructor.name);
+		return parser.stringify(data);
+	}
+	stringifyWith(Parser, data) {
+		const parser = this.fetch(Parser);
+		this.logger.trace("Stringifying data: %s", parser.constructor.name);
+		return parser.stringify(data);
+	}
+};
+ParserService = _decorate([Injectable(), _decorateMetadata("design:paramtypes", [
+	typeof (_ref = typeof ModuleRef !== "undefined" && ModuleRef) === "function" ? _ref : Object,
+	typeof (_ref2 = typeof FileSystemService !== "undefined" && FileSystemService) === "function" ? _ref2 : Object,
+	typeof (_ref3 = typeof LoggerService !== "undefined" && LoggerService) === "function" ? _ref3 : Object
+])], ParserService);
+
+//#endregion
+export { ParserService };

package/dist/lib/setup.d.ts

@@ -0,0 +1,4 @@
+//#region src/lib/setup.d.ts
+declare function setup(): Promise<void>;
+//#endregion
+export { setup };

package/dist/lib/setup.js

@@ -0,0 +1,16 @@
+//#region src/lib/setup.ts
+async function setup() {
+	const inspect = process.argv.indexOf("--inspect");
+	if (inspect !== -1) {
+		await import("inspector").then((mod) => mod.open());
+		process.argv.splice(inspect, 1);
+	}
+	const sourceMaps = process.argv.indexOf("--source-map");
+	if (sourceMaps !== -1) {
+		await import("source-map-support").then((mod) => mod.install());
+		process.argv.splice(sourceMaps, 1);
+	}
+}
+
+//#endregion
+export { setup };

package/dist/lib/validator/index.js

@@ -0,0 +1,3 @@
+import { TOKEN_VALIDATOR_SERVICE_OPTIONS } from "./validator.constants.js";
+import { ValidatorService } from "./validator.service.js";
+import { ValidatorModule } from "./validator.module.js";

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

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

package/dist/lib/validator/validator.constants.js

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

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

@@ -0,0 +1,10 @@
+import { ClassTransformOptions } from "class-transformer";
+import { ValidatorOptions } from "class-validator";
+
+//#region src/lib/validator/validator.interface.d.ts
+interface ValidatorServiceOptions {
+  validator?: ValidatorOptions;
+  transformer?: ClassTransformOptions;
+}
+//#endregion
+export { ValidatorServiceOptions };

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

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

package/dist/lib/validator/validator.module.js

@@ -0,0 +1,13 @@
+import { ValidatorService } from "./validator.service.js";
+import { Global, Module } from "@nestjs/common";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
+
+//#region src/lib/validator/validator.module.ts
+let ValidatorModule = class ValidatorModule$1 {};
+ValidatorModule = _decorate([Global(), Module({
+	providers: [ValidatorService],
+	exports: [ValidatorService]
+})], ValidatorModule);
+
+//#endregion
+export { ValidatorModule };

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

@@ -0,0 +1,19 @@
+import { ClassType } from "../../interfaces/class.interface.js";
+import { LoggerService } from "../logger/logger.service.js";
+import { ValidatorServiceOptions } from "./validator.interface.js";
+import { OnModuleInit } from "@nestjs/common";
+import { ModuleRef } from "@nestjs/core";
+
+//#region src/lib/validator/validator.service.d.ts
+declare class ValidatorService implements OnModuleInit {
+  private readonly logger;
+  private readonly moduleRef;
+  private options;
+  constructor(logger: LoggerService, moduleRef: ModuleRef);
+  onModuleInit(): Promise<void>;
+  validate<T extends Record<PropertyKey, any>>(classType: ClassType<T>, object: T, options?: ValidatorServiceOptions): Promise<T>;
+  validateSync<T extends Record<PropertyKey, any>>(classType: ClassType<T>, object: T, options?: ValidatorServiceOptions): T;
+  private logValidationError;
+}
+//#endregion
+export { ValidatorService };

package/dist/lib/validator/validator.service.js

@@ -0,0 +1,76 @@
+import { LoggerService } from "../logger/logger.service.js";
+import "../logger/index.js";
+import { TOKEN_VALIDATOR_SERVICE_OPTIONS } from "./validator.constants.js";
+import { Injectable } from "@nestjs/common";
+import _decorateMetadata from "@oxc-project/runtime/helpers/decorateMetadata";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
+import { ModuleRef } from "@nestjs/core";
+import { plainToClass } from "class-transformer";
+import { validate, validateSync } from "class-validator";
+
+//#region src/lib/validator/validator.service.ts
+var _ref, _ref2;
+let ValidatorService = class ValidatorService$1 {
+	constructor(logger, moduleRef) {
+		this.logger = logger;
+		this.moduleRef = moduleRef;
+	}
+	async onModuleInit() {
+		this.logger.setup(this.constructor.name);
+		try {
+			this.options = this.moduleRef.get(TOKEN_VALIDATOR_SERVICE_OPTIONS, { strict: false });
+		} catch {
+			this.options = {
+				validator: {
+					skipMissingProperties: true,
+					whitelist: false,
+					always: true,
+					enableDebugMessages: true
+				},
+				transformer: { enableImplicitConversion: true }
+			};
+		}
+	}
+	async validate(classType, object, options) {
+		const classObject = plainToClass(classType, object, {
+			...this.options.transformer,
+			...options?.transformer ?? {}
+		});
+		const errors = await validate(classObject, {
+			...this.options.validator,
+			...options?.validator ?? {}
+		});
+		if (errors.length) {
+			errors.forEach((error) => {
+				this.logValidationError(error);
+			});
+			throw new Error("Validation failed.");
+		}
+		return classObject;
+	}
+	validateSync(classType, object, options) {
+		const classObject = plainToClass(classType, object, {
+			...this.options.transformer,
+			...options?.transformer ?? {}
+		});
+		const errors = validateSync(classObject, {
+			...this.options.validator,
+			...options?.validator ?? {}
+		});
+		if (errors.length) {
+			errors.forEach((error) => {
+				this.logValidationError(error);
+			});
+			throw new Error("Validation failed.");
+		}
+		return classObject;
+	}
+	logValidationError(err) {
+		this.logger.error("Field \"%s\" failed validation with value \"%s\": %o", err.property, err.value, err.constraints);
+		if (err.children) err.children.forEach((children) => this.logValidationError(children));
+	}
+};
+ValidatorService = _decorate([Injectable(), _decorateMetadata("design:paramtypes", [typeof (_ref = typeof LoggerService !== "undefined" && LoggerService) === "function" ? _ref : Object, typeof (_ref2 = typeof ModuleRef !== "undefined" && ModuleRef) === "function" ? _ref2 : Object])], ValidatorService);
+
+//#endregion
+export { ValidatorService };

package/dist/utils/defaults.d.ts

@@ -0,0 +1,12 @@
+import { ListrContext } from "listr2";
+
+//#region src/utils/defaults.d.ts
+type SetCtxDefaultsOptions<T extends ListrContext = ListrContext> = Partial<T>;
+interface SetCtxAssignOptions<K = Record<PropertyKey, any>> {
+  from: K;
+  keys: (keyof K)[];
+}
+declare function setCtxDefaults<T extends ListrContext = ListrContext>(ctx: T, ...defaults: SetCtxDefaultsOptions<T>[]): void;
+declare function setCtxAssign<T extends ListrContext = ListrContext, K = Record<PropertyKey, any>>(ctx: T, ...assigns: SetCtxAssignOptions<K>[]): void;
+//#endregion
+export { SetCtxAssignOptions, SetCtxDefaultsOptions, setCtxAssign, setCtxDefaults };

package/dist/utils/defaults.js

@@ -0,0 +1,16 @@
+//#region src/utils/defaults.ts
+function setCtxDefaults(ctx, ...defaults) {
+	defaults?.forEach((i) => {
+		if (typeof i === "object" && !Array.isArray(i)) Object.assign(ctx, i);
+	});
+}
+function setCtxAssign(ctx, ...assigns) {
+	assigns.forEach((assign) => {
+		assign?.keys.forEach((i) => {
+			if (assign.from[i]) ctx[i] = assign.from[i];
+		});
+	});
+}
+
+//#endregion
+export { setCtxAssign, setCtxDefaults };

package/dist/utils/environment.d.ts

@@ -0,0 +1,8 @@
+import { LogLevels } from "../lib/logger/logger.constants.js";
+
+//#region src/utils/environment.d.ts
+declare function isVerbose(logLevel: LogLevels): boolean;
+declare function isDebug(logLevel: LogLevels): boolean;
+declare function isSilent(logLevel: LogLevels): boolean;
+//#endregion
+export { isDebug, isSilent, isVerbose };

package/dist/utils/environment.js

@@ -0,0 +1,16 @@
+import { LogLevels } from "../lib/logger/logger.constants.js";
+import "../lib/logger/index.js";
+
+//#region src/utils/environment.ts
+function isVerbose(logLevel) {
+	return logLevel === LogLevels.VERBOSE;
+}
+function isDebug(logLevel) {
+	return [LogLevels.DEBUG, LogLevels.TRACE].includes(logLevel);
+}
+function isSilent(logLevel) {
+	return logLevel === LogLevels.SILENT;
+}
+
+//#endregion
+export { isDebug, isSilent, isVerbose };

package/dist/utils/guards.d.ts

@@ -0,0 +1,9 @@
+import { RegisterHook, ShouldRunAfterHook, ShouldRunBeforeHook } from "../interfaces/hooks.interface.js";
+import { Command } from "@oclif/core";
+
+//#region src/utils/guards.d.ts
+declare function isHookedWithShouldRunBefore<T extends Command = Command>(command: T): command is T & ShouldRunBeforeHook;
+declare function isHookedWithShouldRunAfter<T extends Command = Command>(command: T): command is T & ShouldRunAfterHook<any>;
+declare function isHookedWithRegister<T extends Command = Command>(command: T): command is T & RegisterHook;
+//#endregion
+export { isHookedWithRegister, isHookedWithShouldRunAfter, isHookedWithShouldRunBefore };