@cenk1cenk2/oclif-common 6.3.30 → 6.4.0

package/dist/interfaces/class.interface.d.ts

@@ -0,0 +1,4 @@
+//#region src/interfaces/class.interface.d.ts
+type ClassType<T> = new (...args: any[]) => T;
+//#endregion
+export { ClassType };

package/dist/interfaces/hooks.interface.d.ts

@@ -0,0 +1,16 @@
+import { CliModuleOptions } from "../lib/cli.interface.js";
+import { DynamicModule } from "@nestjs/common";
+import { ListrContext } from "listr2";
+
+//#region src/interfaces/hooks.interface.d.ts
+declare class ShouldRunBeforeHook {
+  shouldRunBefore(): void | Promise<void>;
+}
+declare class ShouldRunAfterHook<Ctx extends ListrContext = ListrContext> {
+  shouldRunAfter(ctx: Ctx): void | Promise<void>;
+}
+declare class RegisterHook {
+  register(cli: DynamicModule, options: CliModuleOptions): DynamicModule | Promise<DynamicModule>;
+}
+//#endregion
+export { RegisterHook, ShouldRunAfterHook, ShouldRunBeforeHook };

package/dist/interfaces/index.js

@@ -0,0 +1 @@
+import { Args, Flags } from "./oclif.interface.js";

package/dist/interfaces/oclif.interface.d.ts

@@ -0,0 +1,9 @@
+import { Args, Command, Flags as Flags$1, Interfaces } from "@oclif/core";
+import { Flag, InferredFlags } from "@oclif/core/lib/interfaces";
+import { Arg, ArgInput, FlagInput } from "@oclif/core/lib/interfaces/parser";
+
+//#region src/interfaces/oclif.interface.d.ts
+type InferFlags<T extends typeof Command> = Interfaces.InferredFlags<(typeof Command)['baseFlags'] & T['flags']>;
+type InferArgs<T extends typeof Command> = Interfaces.InferredArgs<T['args']>;
+//#endregion
+export { type Arg, type ArgInput, Args, type Flag, type FlagInput, Flags$1 as Flags, InferArgs, InferFlags, type InferredFlags };

package/dist/interfaces/oclif.interface.js

@@ -0,0 +1,3 @@
+import { Args, Flags as Flags$1 } from "@oclif/core";
+
+export { Args, Flags$1 as Flags };

package/dist/interfaces/type-helper.interface.d.ts

@@ -0,0 +1,7 @@
+//#region src/interfaces/type-helper.interface.d.ts
+/**
+ * Makes the object deep partial.
+ */
+type DeepPartial<T> = { [P in keyof T]?: DeepPartial<T[P]> };
+//#endregion
+export { DeepPartial };

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

@@ -0,0 +1,8 @@
+import { ConfigModuleOptions } from "./config/config.interface.js";
+
+//#region src/lib/cli.interface.d.ts
+interface CliModuleOptions {
+  config: ConfigModuleOptions;
+}
+//#endregion
+export { CliModuleOptions };

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

@@ -0,0 +1,11 @@
+import { CliModuleOptions } from "./cli.interface.js";
+import { DynamicModule, INestApplicationContext } from "@nestjs/common";
+
+//#region src/lib/cli.module.d.ts
+declare class CliModule {
+  static forRoot(options: CliModuleOptions): DynamicModule;
+  static forMinimum(): DynamicModule;
+  static create(cls: DynamicModule): Promise<INestApplicationContext>;
+}
+//#endregion
+export { CliModule };

package/dist/lib/cli.module.js

@@ -0,0 +1,57 @@
+import { TOKEN_CONFIG_MODULE_OPTIONS } from "./config/config.constants.js";
+import { LogLevels } from "./logger/logger.constants.js";
+import { LoggerModule } from "./logger/logger.module.js";
+import "./logger/index.js";
+import { FilesystemModule } from "./fs/filesystem.module.js";
+import "./fs/index.js";
+import { ParserModule } from "./parser/parser.module.js";
+import { ConfigModule } from "./config/config.module.js";
+import "./config/index.js";
+import "./parser/index.js";
+import { LogoModule } from "./logo/logo.module.js";
+import "./logo/index.js";
+import { NestFactory } from "@nestjs/core";
+
+//#region src/lib/cli.module.ts
+var CliModule = class CliModule {
+	static forRoot(options) {
+		return {
+			module: CliModule,
+			global: true,
+			imports: [
+				ConfigModule,
+				LoggerModule,
+				FilesystemModule,
+				ParserModule,
+				LogoModule
+			],
+			providers: [{
+				provide: TOKEN_CONFIG_MODULE_OPTIONS,
+				useValue: options.config
+			}],
+			exports: [TOKEN_CONFIG_MODULE_OPTIONS]
+		};
+	}
+	static forMinimum() {
+		return {
+			module: CliModule,
+			global: true,
+			imports: [LoggerModule],
+			providers: [{
+				provide: TOKEN_CONFIG_MODULE_OPTIONS,
+				useValue: { config: {
+					logLevel: LogLevels.INFO,
+					isJson: false
+				} }
+			}],
+			exports: [TOKEN_CONFIG_MODULE_OPTIONS]
+		};
+	}
+	static create(cls) {
+		if (process.env.LOG_LEVEL === "trace") process.env.NEST_DEBUG = "true";
+		return NestFactory.createApplicationContext(cls, { logger: [process.env.LOG_LEVEL === "trace" ? "debug" : "error"] });
+	}
+};
+
+//#endregion
+export { CliModule };

package/dist/lib/config/config.constants.js

@@ -0,0 +1,12 @@
+//#region src/lib/config/config.constants.ts
+let ConfigEnvKeys = /* @__PURE__ */ function(ConfigEnvKeys$1) {
+	ConfigEnvKeys$1["NAME"] = "__name";
+	ConfigEnvKeys$1["PARSER"] = "__format";
+	ConfigEnvKeys$1["ELEMENT"] = "__element";
+	ConfigEnvKeys$1["ELEMENT_REPLACER"] = "${i}";
+	return ConfigEnvKeys$1;
+}({});
+const TOKEN_CONFIG_MODULE_OPTIONS = Symbol("TOKEN_CONFIG_MODULE_OPTIONS");
+
+//#endregion
+export { ConfigEnvKeys, TOKEN_CONFIG_MODULE_OPTIONS };

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

@@ -0,0 +1,21 @@
+import { LogLevels } from "../logger/logger.constants.js";
+import { Command, Config } from "@oclif/core";
+
+//#region src/lib/config/config.interface.d.ts
+interface GlobalConfig {
+  logLevel: LogLevels;
+  isJson: boolean;
+}
+interface ConfigIterator {
+  key: (string | number)[];
+  env: string;
+  parser?: string;
+  extensions?: ConfigIterator[];
+}
+interface ConfigModuleOptions {
+  oclif?: Config;
+  command?: typeof Command;
+  config: GlobalConfig;
+}
+//#endregion
+export { ConfigIterator, ConfigModuleOptions, GlobalConfig };

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

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

package/dist/lib/config/config.module.js

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

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

@@ -0,0 +1,32 @@
+import { ConfigModuleOptions, GlobalConfig } from "./config.interface.js";
+import { LoggerService } from "../logger/logger.service.js";
+import { ParserService } from "../parser/parser.service.js";
+import { MergeStrategy } from "../../utils/merge.constants.js";
+import { LockableData } from "../locker/locker.interface.js";
+import { OnModuleInit } from "@nestjs/common";
+import { Command, Config } from "@oclif/core";
+
+//#region src/lib/config/config.service.d.ts
+declare class ConfigService implements OnModuleInit {
+  private readonly parser;
+  private readonly logger;
+  private options;
+  defaults: string;
+  root: string;
+  config: GlobalConfig;
+  oclif: Config;
+  command: typeof Command;
+  constructor(parser: ParserService, logger: LoggerService, options: ConfigModuleOptions);
+  onModuleInit(): Promise<void>;
+  get isVerbose(): boolean;
+  get isDebug(): boolean;
+  get isSilent(): boolean;
+  get isJson(): boolean;
+  read<T extends LockableData = LockableData>(path: string): Promise<T>;
+  extend<T extends LockableData = LockableData>(paths: (string | Partial<T>)[], strategy?: MergeStrategy): Promise<T>;
+  merge<T extends LockableData = LockableData>(configs: Partial<T>[], strategy?: MergeStrategy): T;
+  env<T extends LockableData = LockableData>(definition: string | Record<PropertyKey, any>, config: T): Promise<T>;
+  write<T extends LockableData = LockableData>(path: string, data: T): Promise<void>;
+}
+//#endregion
+export { ConfigService };

package/dist/lib/config/config.service.js

@@ -0,0 +1,152 @@
+import { FileConstants } from "../../constants/file.constants.js";
+import { ConfigEnvKeys, TOKEN_CONFIG_MODULE_OPTIONS } from "./config.constants.js";
+import { LoggerService } from "../logger/logger.service.js";
+import "../logger/index.js";
+import { ParserService } from "../parser/parser.service.js";
+import { isDebug, isSilent, isVerbose } from "../../utils/environment.js";
+import { MergeStrategy } from "../../utils/merge.constants.js";
+import { merge } from "../../utils/merge.js";
+import "../../utils/index.js";
+import { Inject, Injectable } from "@nestjs/common";
+import op from "object-path-immutable";
+import { join } from "path";
+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/config/config.service.ts
+var _ref, _ref2;
+let ConfigService = class ConfigService$1 {
+	constructor(parser, logger, options) {
+		this.parser = parser;
+		this.logger = logger;
+		this.options = options;
+	}
+	async onModuleInit() {
+		this.root = this.options.oclif?.root;
+		this.defaults = join(this.options.oclif?.root, FileConstants.CONFIG_SERVICE_DEFAULTS_DIR);
+		this.oclif = this.options.oclif;
+		this.config = this.options.config;
+		this.command = this.options.command;
+		this.logger.setup(this.constructor.name);
+	}
+	get isVerbose() {
+		return isVerbose(this.config.logLevel);
+	}
+	get isDebug() {
+		return isDebug(this.config.logLevel);
+	}
+	get isSilent() {
+		return isSilent(this.config.logLevel);
+	}
+	get isJson() {
+		return this.config.isJson;
+	}
+	async read(path) {
+		const config = await this.parser.read(path);
+		this.logger.trace("Read config from: %s", path);
+		return config;
+	}
+	async extend(paths, strategy = MergeStrategy.OVERWRITE) {
+		this.logger.trace("Will generate config from: %o with %s", paths, strategy);
+		const configs = (await Promise.all(paths.map(async (path) => {
+			try {
+				const config = typeof path === "string" ? await this.parser.read(path) : path;
+				this.logger.trace("Extending config from: %s", path);
+				return config;
+			} catch (e) {
+				this.logger.trace("Failed to extend config from: %s", e.message);
+			}
+		}))).filter(Boolean);
+		return this.merge(configs, strategy);
+	}
+	merge(configs, strategy = MergeStrategy.OVERWRITE) {
+		if (configs.length === 0) throw new Error("Nothing to merge, configuration files are empty.");
+		return merge(strategy, ...configs);
+	}
+	async env(definition, config) {
+		const env = typeof definition === "string" ? await this.parser.read(definition) : definition;
+		this.logger.trace("Environment variable extensions read: %o", definition);
+		const iter = async (obj, parent) => {
+			const data = await Promise.all(Object.entries(obj).map(async ([key, value]) => {
+				const location = [...parent ?? [], key];
+				if (typeof value === "string") return [{
+					key: location,
+					env: value
+				}];
+				else if (typeof value === "object") {
+					let extensions;
+					if (ConfigEnvKeys.ELEMENT in value) {
+						extensions = await iter(value[ConfigEnvKeys.ELEMENT], [...location, ConfigEnvKeys.ELEMENT]);
+						this.logger.trace("Expanding location to elements: %s -> %s", location, extensions.map((extension) => extension.key.join(".")).join(", "));
+					}
+					if (ConfigEnvKeys.NAME in value && ConfigEnvKeys.PARSER in value) {
+						const variable = [{
+							key: location,
+							env: value[ConfigEnvKeys.NAME],
+							parser: value[ConfigEnvKeys.PARSER],
+							extensions
+						}];
+						return variable;
+					} else return iter(value, location);
+				}
+			}));
+			return data.flatMap((d) => d).filter(Boolean);
+		};
+		const parsed = await iter(env);
+		const cb = (config$1, variable, data) => {
+			if (variable.parser) try {
+				data = this.parser.parse(variable.parser, data);
+			} catch (e) {
+				this.logger.trace("Can not parse environment environment variable for config: %s -> %s with %s", variable.key.join("."), variable.env, variable.parser);
+				throw e;
+			}
+			this.logger.trace("Overwriting config with environment variable: %s -> %s", variable.key.join("."), variable.env);
+			return op.set(config$1, variable.key, data);
+		};
+		parsed.forEach((variable) => {
+			let data;
+			data = process.env[variable.env];
+			if (data) config = cb(config, variable, data);
+			if (variable.extensions && variable.extensions.length > 0) {
+				const timeout = 6e4;
+				const startedAt = Date.now();
+				for (let i = 0; i < Infinity; i++) {
+					if (Date.now() - startedAt > timeout) throw new Error(`Timed-out in ${timeout}ms while looking for element environment variables.`);
+					const extensions = variable.extensions.map((extension) => {
+						const clone = JSON.parse(JSON.stringify(extension));
+						clone.env = clone.env.replace(ConfigEnvKeys.ELEMENT_REPLACER, i.toString());
+						clone.key[clone.key.findIndex((value) => value === ConfigEnvKeys.ELEMENT)] = i.toString();
+						data = process.env[clone.env];
+						if (!data) {
+							this.logger.trace("No extension for environment variable: %s -> %s", clone.key.join("."), clone.env);
+							return;
+						}
+						config = cb(config, clone, data);
+						return true;
+					}).filter(Boolean);
+					if (extensions.length === 0) {
+						this.logger.trace("No more extensions for environment variables: %s -> %d", variable.key.join("."), i);
+						break;
+					}
+				}
+			}
+		});
+		return config;
+	}
+	async write(path, data) {
+		return this.parser.write(path, data);
+	}
+};
+ConfigService = _decorate([
+	Injectable(),
+	_decorateMetadata("design:paramtypes", [
+		typeof (_ref = typeof ParserService !== "undefined" && ParserService) === "function" ? _ref : Object,
+		typeof (_ref2 = typeof LoggerService !== "undefined" && LoggerService) === "function" ? _ref2 : Object,
+		Object
+	]),
+	_decorateParam(2, Inject(TOKEN_CONFIG_MODULE_OPTIONS))
+], ConfigService);
+
+//#endregion
+export { ConfigService };

package/dist/lib/config/index.js

@@ -0,0 +1,2 @@
+import { ConfigService } from "./config.service.js";
+import { ConfigModule } from "./config.module.js";

package/dist/lib/fs/filesystem.interface.d.ts

@@ -0,0 +1,2 @@
+import fs$1 from "fs-extra";
+export { type fs$1 as fs };

package/dist/lib/fs/filesystem.module.d.ts

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

package/dist/lib/fs/filesystem.module.js

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

package/dist/lib/fs/filesystem.service.d.ts

@@ -0,0 +1,31 @@
+import { LoggerService } from "../logger/logger.service.js";
+import { OnModuleInit } from "@nestjs/common";
+import fs from "fs-extra";
+
+//#region src/lib/fs/filesystem.service.d.ts
+declare class FileSystemService implements OnModuleInit {
+  private readonly logger;
+  readonly extra: typeof fs;
+  constructor(logger: LoggerService);
+  onModuleInit(): Promise<void>;
+  exists(path: string): boolean;
+  stats(path: string): fs.Stats;
+  dirname(path: string): string;
+  extname(path: string): string;
+  read(file: string): Promise<string>;
+  readSync(file: string): string;
+  write(file: string, data: string | Buffer, options?: fs.WriteFileOptions): Promise<void>;
+  writeSync(file: string, data: string | Buffer, options?: fs.WriteFileOptions): void;
+  append(file: string, data: string | Buffer, options?: fs.WriteFileOptions): Promise<void>;
+  appendSync(file: string, data: string | Buffer): void;
+  remove(file: string, options?: fs.RmOptions): Promise<void>;
+  removeSync(file: string, options?: fs.RmOptions): void;
+  emptyDir(directory: string): Promise<void>;
+  emptyDirSync(directory: string): void;
+  removeDir(directory: string): Promise<void>;
+  removeDirSync(directory: string): void;
+  mkdir(directory: string): Promise<void>;
+  mkdirSync(directory: string): void;
+}
+//#endregion
+export { FileSystemService };

package/dist/lib/fs/filesystem.service.js

@@ -0,0 +1,141 @@
+import { LoggerService } from "../logger/logger.service.js";
+import "../logger/index.js";
+import { Injectable } from "@nestjs/common";
+import { dirname, extname } from "path";
+import _decorateMetadata from "@oxc-project/runtime/helpers/decorateMetadata";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
+import fs from "fs-extra";
+
+//#region src/lib/fs/filesystem.service.ts
+var _ref;
+let FileSystemService = class FileSystemService$1 {
+	constructor(logger) {
+		this.logger = logger;
+		this.extra = fs;
+	}
+	async onModuleInit() {
+		this.logger.setup(this.constructor.name);
+	}
+	exists(path) {
+		return this.extra.existsSync(path);
+	}
+	stats(path) {
+		return this.extra.statSync(path, { throwIfNoEntry: true });
+	}
+	dirname(path) {
+		return dirname(path);
+	}
+	extname(path) {
+		return extname(path);
+	}
+	async read(file) {
+		try {
+			const raw = await this.extra.readFile(file, "utf-8");
+			return raw;
+		} catch (e) {
+			throw new Error(`Error while reading file from "${file}": ${e.message}`);
+		}
+	}
+	readSync(file) {
+		try {
+			const raw = this.extra.readFileSync(file, "utf-8");
+			return raw;
+		} catch (e) {
+			throw new Error(`Error while reading file from "${file}": ${e.message}`);
+		}
+	}
+	async write(file, data, options = {}) {
+		try {
+			await this.extra.writeFile(file, data, typeof options === "object" ? {
+				encoding: "utf-8",
+				...options
+			} : options);
+		} catch (e) {
+			throw new Error(`Error while writing file to "${file}": ${e.message}`);
+		}
+	}
+	writeSync(file, data, options = {}) {
+		try {
+			this.extra.writeFileSync(file, data, typeof options === "object" ? {
+				encoding: "utf-8",
+				...options
+			} : options);
+		} catch (e) {
+			throw new Error(`Error while writing file to "${file}": ${e.message}`);
+		}
+	}
+	async append(file, data, options) {
+		try {
+			await this.extra.appendFile(file, data, options);
+		} catch (e) {
+			throw new Error(`Error while appending to file  "${file}": ${e.message}`);
+		}
+	}
+	appendSync(file, data) {
+		try {
+			this.extra.appendFileSync(file, data);
+		} catch (e) {
+			throw new Error(`Error while appending to file  "${file}": ${e.message}`);
+		}
+	}
+	async remove(file, options) {
+		try {
+			await this.extra.rm(file, options);
+		} catch (e) {
+			throw new Error(`Error while deleting the file "${file}": ${e.message}`);
+		}
+	}
+	removeSync(file, options) {
+		try {
+			this.extra.rmSync(file, options);
+		} catch (e) {
+			throw new Error(`Error while deleting the file "${file}": ${e.message}`);
+		}
+	}
+	async emptyDir(directory) {
+		try {
+			await this.extra.emptyDir(directory);
+		} catch (e) {
+			throw new Error(`Error while emptying the directory "${directory}": ${e.message}`);
+		}
+	}
+	emptyDirSync(directory) {
+		try {
+			this.extra.emptyDirSync(directory);
+		} catch (e) {
+			throw new Error(`Error while emptying the directory "${directory}": ${e.message}`);
+		}
+	}
+	async removeDir(directory) {
+		try {
+			await this.extra.rmdir(directory);
+		} catch (e) {
+			throw new Error(`Error while removing the directory "${directory}": ${e.message}`);
+		}
+	}
+	removeDirSync(directory) {
+		try {
+			this.extra.rmdirSync(directory);
+		} catch (e) {
+			throw new Error(`Error while removing the directory "${directory}": ${e.message}`);
+		}
+	}
+	async mkdir(directory) {
+		try {
+			await this.extra.mkdirp(directory);
+		} catch (e) {
+			throw new Error(`Error while creating the directory "${directory}": ${e.message}`);
+		}
+	}
+	mkdirSync(directory) {
+		try {
+			this.extra.mkdirpSync(directory);
+		} catch (e) {
+			throw new Error(`Error while creating the directory "${directory}": ${e.message}`);
+		}
+	}
+};
+FileSystemService = _decorate([Injectable(), _decorateMetadata("design:paramtypes", [typeof (_ref = typeof LoggerService !== "undefined" && LoggerService) === "function" ? _ref : Object])], FileSystemService);
+
+//#endregion
+export { FileSystemService };

package/dist/lib/fs/index.js

@@ -0,0 +1,2 @@
+import { FileSystemService } from "./filesystem.service.js";
+import { FilesystemModule } from "./filesystem.module.js";

package/dist/lib/index.js

@@ -0,0 +1,32 @@
+import { pipeProcessThroughListr } from "./logger/pipe/pipe-process-to-listr.js";
+import { LogFieldStatus, LogLevels } from "./logger/logger.constants.js";
+import { pipeProcessToLogger } from "./logger/pipe/pipe-process-to-logger.js";
+import { WinstonService } from "./logger/winston.service.js";
+import { LoggerService } from "./logger/logger.service.js";
+import { LoggerModule } from "./logger/logger.module.js";
+import "./logger/index.js";
+import { FileSystemService } from "./fs/filesystem.service.js";
+import { FilesystemModule } from "./fs/filesystem.module.js";
+import "./fs/index.js";
+import { ParserService } from "./parser/parser.service.js";
+import { ConfigService } from "./config/config.service.js";
+import { ParserModule } from "./parser/parser.module.js";
+import { ConfigModule } from "./config/config.module.js";
+import "./config/index.js";
+import { EnvironmentVariableParser } from "./parser/fts/env-parser.service.js";
+import { JsonParser } from "./parser/fts/json-parser.service.js";
+import { YamlParser } from "./parser/fts/yaml-parser.service.js";
+import "./parser/index.js";
+import { LockerService } from "./locker/locker.service.js";
+import { LockerModule } from "./locker/locker.module.js";
+import "./locker/index.js";
+import { TOKEN_LOGO_GENERATOR } from "./logo/logo.constants.js";
+import { LogoService } from "./logo/logo.service.js";
+import { LogoModule } from "./logo/logo.module.js";
+import "./logo/index.js";
+import { TOKEN_VALIDATOR_SERVICE_OPTIONS } from "./validator/validator.constants.js";
+import { ValidatorService } from "./validator/validator.service.js";
+import { ValidatorModule } from "./validator/validator.module.js";
+import "./validator/index.js";
+import { setup } from "./setup.js";
+import { CliModule } from "./cli.module.js";

package/dist/lib/locker/index.js

@@ -0,0 +1,2 @@
+import { LockerService } from "./locker.service.js";
+import { LockerModule } from "./locker.module.js";

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

@@ -0,0 +1,28 @@
+import { ClassType } from "../../interfaces/class.interface.js";
+import { GenericParser } from "../parser/parser.interface.js";
+import { MergeStrategy } from "../../utils/merge.constants.js";
+import { InjectionToken } from "@nestjs/common";
+
+//#region src/lib/locker/locker.interface.d.ts
+interface CommonLockerData {
+  path?: string | string[];
+  enabled?: boolean;
+  root?: boolean;
+}
+type LockableData = any;
+interface LockData<T extends LockableData = LockableData> extends Partial<CommonLockerData> {
+  data: T;
+  merge?: MergeStrategy;
+}
+interface UnlockData extends CommonLockerData {
+  path: string | string[];
+}
+interface LockerServiceOptions {
+  file: string;
+  parser: ClassType<GenericParser>;
+  root?: string[];
+  context?: string;
+  token?: InjectionToken;
+}
+//#endregion
+export { CommonLockerData, LockData, LockableData, LockerServiceOptions, UnlockData };

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

@@ -0,0 +1,9 @@
+import { LockerServiceOptions } from "./locker.interface.js";
+import { DynamicModule } from "@nestjs/common";
+
+//#region src/lib/locker/locker.module.d.ts
+declare class LockerModule {
+  static forFeature(options: LockerServiceOptions): DynamicModule;
+}
+//#endregion
+export { LockerModule };