@conformetry/nx 0.0.1

package/dist/plugin-context.utilities-CuP36-vK.js

@@ -0,0 +1,973 @@
+import "reflect-metadata";
+import { NestFactory as e } from "@nestjs/core";
+import { ConsoleLogger as t, Global as n, Injectable as r, Module as i, Scope as a } from "@nestjs/common";
+import o, { existsSync as s, mkdirSync as c, readFileSync as l, readdirSync as u } from "node:fs";
+import d from "node:path";
+import f from "pino";
+import { ConfigurationModule as p, ConfigurationService as m } from "@conformetry/configuration";
+import { GenerationModule as h, GenerationService as g } from "@conformetry/generation";
+import { ReportingModule as _, ReportingService as v } from "@conformetry/output";
+import { ValidationModule as y, ValidationService as b } from "@conformetry/validation";
+import { formatFiles as ee, getProjects as te, readProjectConfiguration as ne } from "@nx/devkit";
+//#region packages/logger/src/modules/logger/logger.constants.ts
+var re = /^(\p{Extended_Pictographic}️?(?:‍\p{Extended_Pictographic}️?)*)\s+/u, ie = /^([A-Za-z]+)/, ae = /* @__PURE__ */ new Set([
+	"built",
+	"cut",
+	"found",
+	"got",
+	"kept",
+	"left",
+	"lost",
+	"made",
+	"put",
+	"ran",
+	"read",
+	"rebuilt",
+	"sent",
+	"set",
+	"split",
+	"took",
+	"wrote"
+]), oe = /* @__PURE__ */ new Set([
+	"CommandFactory",
+	"ExceptionHandler",
+	"GraphQLModule",
+	"InstanceLoader",
+	"NestApplication",
+	"NestFactory",
+	"RouterExplorer",
+	"RoutesResolver",
+	"TypeOrmModule"
+]);
+//#endregion
+//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorateMetadata.js
+function x(e, t) {
+	if (typeof Reflect == "object" && typeof Reflect.metadata == "function") return Reflect.metadata(e, t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorate.js
+function S(e, t, n, r) {
+	var i = arguments.length, a = i < 3 ? t : r === null ? r = Object.getOwnPropertyDescriptor(t, n) : r, o;
+	if (typeof Reflect == "object" && typeof Reflect.decorate == "function") a = Reflect.decorate(e, t, n, r);
+	else for (var s = e.length - 1; s >= 0; s--) (o = e[s]) && (a = (i < 3 ? o(a) : i > 3 ? o(t, n, a) : o(t, n)) || a);
+	return i > 3 && a && Object.defineProperty(t, n, a), a;
+}
+//#endregion
+//#region packages/logger/src/modules/logger/logger.service.ts
+var C, w = class extends t {
+	static {
+		C = this;
+	}
+	constructor() {
+		super();
+	}
+	static isProduction = process.env.NODE_ENV === "production";
+	static rootLogger;
+	static writesToStandardError = !1;
+	child = C.root;
+	static createRootLogger() {
+		let e = process.env.LOG_LEVEL ?? "info";
+		return C.isProduction ? C.writesToStandardError ? f({ level: e }, f.destination(2)) : f({ level: e }) : f({
+			level: e,
+			transport: {
+				options: {
+					colorize: !0,
+					destination: C.writesToStandardError ? 2 : 1,
+					ignore: "pid,hostname,emoji",
+					messageFormat: "{emoji} {msg}",
+					singleLine: !0
+				},
+				target: "pino-pretty"
+			}
+		});
+	}
+	static logToStandardError() {
+		if (C.rootLogger !== void 0) {
+			process.emitWarning("LoggerService.logToStandardError() was called after the first log line, so log lines still go to standard output and anything piping that stream will read them as data. Call it as the first statement of the application's bootstrap.");
+			return;
+		}
+		C.writesToStandardError = !0;
+	}
+	assertConventionalMessage(e) {
+		if (C.isProduction || this.shouldSkipConventionalMessageValidation(e.context)) return;
+		let t = this.getConventionalMessageViolation(e.parsed);
+		if (t !== void 0) throw Error(t);
+	}
+	buildBindings(e) {
+		return this.assertConventionalMessage({
+			context: e.context,
+			parsed: e.parsed
+		}), {
+			...e.data,
+			context: e.context,
+			...C.isProduction ? {} : { emoji: e.parsed.emoji }
+		};
+	}
+	getConventionalMessageViolation(e) {
+		let t = e.emoji, n = e.text;
+		if (t === void 0) return `Log message must start with an emoji naming its subject, then a verb: "${n}"`;
+		let r = ie.exec(n)?.[1];
+		if (r === void 0 || !this.isConventionalVerb(r)) return `Log message must begin with a verb in present progressive or past tense, got "${r ?? ""}": "${t} ${n}"`;
+	}
+	isConventionalVerb(e) {
+		let t = e.toLowerCase();
+		return t.endsWith("ing") || t.endsWith("ed") || ae.has(t);
+	}
+	parseMessage(e) {
+		let t = String(e), n = re.exec(t), r = n?.[1];
+		return r === void 0 ? {
+			emoji: void 0,
+			text: t
+		} : {
+			emoji: r,
+			text: t.slice(n?.[0].length)
+		};
+	}
+	shouldSkipConventionalMessageValidation(e) {
+		return e !== void 0 && oe.has(e);
+	}
+	static get root() {
+		return C.rootLogger ??= C.createRootLogger(), C.rootLogger;
+	}
+	buildErrorLogEntry(e, t) {
+		let n = t instanceof Error ? t.stack || t.message : String(t);
+		return {
+			errorMessage: n,
+			logLine: `[${(/* @__PURE__ */ new Date()).toISOString()}] ${e}: ${n}\n`
+		};
+	}
+	createTimestampedOutputLogFilePath(e) {
+		let t = d.join(process.cwd(), "output");
+		return s(t) || c(t, { recursive: !0 }), d.join(t, `${e}-${(/* @__PURE__ */ new Date()).toISOString().replaceAll(/[:.]/g, "-")}.log`);
+	}
+	debug(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.debug(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	error(e, t, n) {
+		let r = this.parseMessage(e), i = typeof n == "object" ? n : void 0, a = typeof n == "string" ? n : this.context;
+		this.child.error({
+			...this.buildBindings({
+				context: a,
+				data: i,
+				parsed: r
+			}),
+			stack: t
+		}, r.text);
+	}
+	info(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.info(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	log(e, t, n) {
+		this.info(e, t, n);
+	}
+	setContext(e) {
+		super.setContext(e), this.child = C.root.child({ context: e });
+	}
+	verbose(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.trace(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	warn(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.warn(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+};
+w = C = S([r({ scope: a.TRANSIENT }), x("design:paramtypes", [])], w);
+//#endregion
+//#region packages/logger/src/modules/logger/logger.module.ts
+var T = class {};
+T = S([n(), i({
+	controllers: [],
+	exports: [w],
+	imports: [],
+	providers: [w]
+})], T);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-nx/src/modules/scope/scope.service.ts
+var E = class {
+	configurationService;
+	constructor(e) {
+		this.configurationService = e;
+	}
+	isProjectGroup(e) {
+		return this.configurationService.isProjectScoped(e);
+	}
+	matchesProject(e) {
+		return !this.isProjectGroup(e.group) || (e.group.tags ?? []).every((t) => e.project.tags.includes(t));
+	}
+	resolveGroup(e) {
+		let t = e.group.patterns;
+		return !this.matchesProject(e) || t === void 0 || t.length === 0 ? [] : this.isProjectGroup(e.group) ? [{
+			...e.group,
+			patterns: t.map((t) => d.posix.join(e.project.root, t))
+		}] : [e.group];
+	}
+	resolveScopedDirectory(e) {
+		let [t] = e.find((e) => this.isProjectGroup(e))?.patterns ?? [];
+		if (t === void 0 || t === ".") return;
+		let n = t.split("/"), r = n.findIndex((e) => e.includes("*")), i = r === -1 ? n : n.slice(0, r);
+		return i.length === 0 ? void 0 : i.join("/");
+	}
+	resolveScopedProjectNames(e) {
+		let t = e.groups.filter((e) => this.isProjectGroup(e));
+		return t.length === 0 ? [] : e.projects.filter((e) => t.some((t) => this.matchesProject({
+			group: t,
+			project: e
+		}))).map((e) => e.name).toSorted((e, t) => e.localeCompare(t));
+	}
+};
+E = S([r(), x("design:paramtypes", [m === void 0 ? Object : m])], E);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-nx/src/modules/scope/scope.module.ts
+var D = class {};
+D = S([i({
+	controllers: [],
+	exports: [E],
+	imports: [p],
+	providers: [E]
+})], D);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-nx/src/modules/paths/paths.constants.ts
+var O = "project", se = "module", k = "type", A = "directory", j = ".conformetry/nx-generators", ce = "// Generated from the conformetry configuration. Do not edit.", le = "The conformetry generator plugin is out of sync with the conformetry configuration.", M = "conformetry", ue = "node_modules/@nx/devkit/src/generators/generators-schema.json", N = class {
+	configurationService;
+	scopeService;
+	constructor(e, t) {
+		this.configurationService = e, this.scopeService = t;
+	}
+	buildGeneratorModule(e) {
+		return [
+			ce,
+			"",
+			"import { runConformetryGenerator } from \"@conformetry/nx\";",
+			"",
+			"import type { Tree } from \"@nx/devkit\";",
+			"",
+			"/**",
+			` * Runs the \`${e.name}\` conformetry generator.`,
+			" */",
+			"export async function generate(",
+			"  tree: Tree,",
+			"  options?: Record<string, unknown>,",
+			"): Promise<void> {",
+			"  await runConformetryGenerator({",
+			`    generatorName: "${e.name}",`,
+			"    ...(options === undefined ? {} : { options }),",
+			"    tree,",
+			"  });",
+			"}",
+			""
+		].join("\n");
+	}
+	buildGeneratorsManifest(e) {
+		let t = {};
+		for (let n of e.definitions) t[n.name] = {
+			...n.description === void 0 ? {} : { description: n.description },
+			factory: `./src/generators/${n.name}#generate`,
+			schema: `./src/schemas/${n.name}.json`
+		};
+		return this.stringify({
+			$schema: d.relative(e.outputPath, ue).split(d.sep).join("/"),
+			generators: t
+		});
+	}
+	buildSchema(e) {
+		return this.stringify({
+			$schema: "http://json-schema.org/schema",
+			...e.definition.description === void 0 ? {} : { description: e.definition.description },
+			properties: this.buildSchemaProperties(e),
+			required: Object.keys(e.definition.inputs),
+			title: e.definition.name,
+			type: "object"
+		});
+	}
+	buildSchemaProperties(e) {
+		let t = e.definition.inputs[O];
+		return t === void 0 || e.scopedProjectNames === void 0 || e.scopedProjectNames.length === 0 ? e.definition.inputs : {
+			...e.definition.inputs,
+			[O]: {
+				...t,
+				enum: e.scopedProjectNames,
+				"x-prompt": {
+					items: e.scopedProjectNames,
+					message: `Which project should this ${e.definition.name} go in?`,
+					type: "list"
+				}
+			}
+		};
+	}
+	resolveScopedProjectNames(e) {
+		if (e.projects === void 0) return;
+		let t = this.scopeService.resolveScopedProjectNames({
+			groups: e.definition.instances,
+			projects: [...e.projects]
+		});
+		return t.length === 0 ? void 0 : t;
+	}
+	stringify(e) {
+		return `${JSON.stringify(e, void 0, 2)}\n`;
+	}
+	async emitPlugin(e) {
+		let t = (await this.configurationService.loadConformetryConfiguration(e.configurationPath)).toSorted((e, t) => e.name.localeCompare(t.name));
+		return [
+			{
+				content: this.buildGeneratorsManifest({
+					definitions: t,
+					outputPath: e.outputPath
+				}),
+				filePath: d.join(e.outputPath, "generators.json")
+			},
+			...t.map((t) => ({
+				content: this.buildGeneratorModule(t),
+				filePath: d.join(e.outputPath, `src/generators/${t.name}.ts`)
+			})),
+			...t.map((t) => ({
+				content: this.buildSchema({
+					definition: t,
+					scopedProjectNames: this.resolveScopedProjectNames({
+						definition: t,
+						projects: e.projects
+					})
+				}),
+				filePath: d.join(e.outputPath, `src/schemas/${t.name}.json`)
+			})),
+			{
+				content: this.stringify({
+					dependencies: {
+						"@conformetry/nx": "workspace:*",
+						"@nx/devkit": "catalog:"
+					},
+					generators: "./generators.json",
+					name: e.packageName,
+					nx: { generators: "./generators.json" },
+					private: !0,
+					type: "module",
+					version: "0.0.1"
+				}),
+				filePath: d.join(e.outputPath, "package.json")
+			}
+		];
+	}
+};
+N = S([r(), x("design:paramtypes", [m === void 0 ? Object : m, E === void 0 ? Object : E])], N);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-nx/src/modules/generator/generator.module.ts
+var P = class {};
+P = S([i({
+	controllers: [],
+	exports: [
+		p,
+		N,
+		D
+	],
+	imports: [p, D],
+	providers: [N]
+})], P);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-nx/src/modules/adapter/adapter.constants.ts
+var de = "utf8", F = class {
+	constructor() {}
+	async listDirectory(e) {
+		let t = this.resolveTreePath(e);
+		return t === void 0 ? o.readdirSync(e.directoryPath, { withFileTypes: !0 }).map((e) => ({
+			isDirectory: e.isDirectory(),
+			name: e.name
+		})) : await Promise.resolve(e.tree.children(t).map((n) => ({
+			isDirectory: !e.tree.isFile([t, n].join("/")),
+			name: n
+		})));
+	}
+	async readFile(e) {
+		let t = this.resolveTreePath({
+			directoryPath: e.filePath,
+			workspaceRoot: e.workspaceRoot
+		}), n = t === void 0 ? null : e.tree.read(t, de);
+		return await Promise.resolve(n ?? o.readFileSync(e.filePath, "utf8"));
+	}
+	resolveTreePath(e) {
+		let t = d.relative(e.workspaceRoot, e.directoryPath);
+		if (!(t.startsWith("..") || d.isAbsolute(t))) return t.split(d.sep).join("/");
+	}
+	createAdapters(e) {
+		return {
+			filesystem: {
+				listDirectory: async (t) => await this.listDirectory({
+					directoryPath: t,
+					tree: e.tree,
+					workspaceRoot: e.workspaceRoot
+				}),
+				makeDirectory: async () => {
+					await Promise.resolve();
+				},
+				readFile: async (t) => await this.readFile({
+					filePath: t,
+					tree: e.tree,
+					workspaceRoot: e.workspaceRoot
+				}),
+				writeFile: async (t, n) => {
+					let r = this.resolveTreePath({
+						directoryPath: t,
+						workspaceRoot: e.workspaceRoot
+					});
+					e.tree.write(r ?? t, n), await Promise.resolve();
+				}
+			},
+			formatter: { formatFiles: async () => {
+				await ee(e.tree);
+			} }
+		};
+	}
+};
+F = S([r(), x("design:paramtypes", [])], F);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-nx/src/modules/adapter/adapter.module.ts
+var I = class {};
+I = S([i({
+	controllers: [],
+	exports: [F],
+	imports: [],
+	providers: [F]
+})], I);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-nx/src/modules/instances/instances.service.ts
+var L = class {
+	configurationService;
+	scopeService;
+	constructor(e, t) {
+		this.configurationService = e, this.scopeService = t;
+	}
+	isInsideProject(e) {
+		let t = d.relative(e.projectRootPath, d.join(e.instance.path, e.instance.nameStem));
+		return t !== ".." && !t.startsWith(`..${d.sep}`) && !d.isAbsolute(t);
+	}
+	async findProjectInstances(e) {
+		let t = await this.configurationService.loadConformetryConfiguration(e.configurationPath), n = d.resolve(e.workspaceRoot, e.project.root), r = t.flatMap((e) => e.instances).flatMap((t) => this.scopeService.resolveGroup({
+			group: t,
+			project: e.project
+		})).flatMap((t) => this.configurationService.findInstances({
+			patterns: t.patterns ?? [],
+			...t.substitutions === void 0 ? {} : { substitutions: t.substitutions },
+			...t.threshold === void 0 ? {} : { threshold: t.threshold },
+			workingDirectory: e.workspaceRoot
+		})).filter((e) => this.isInsideProject({
+			instance: e,
+			projectRootPath: n
+		})), i = /* @__PURE__ */ new Set();
+		return r.filter((e) => {
+			let t = [
+				e.path,
+				e.nameStem,
+				(e.fileScope ?? []).join(",")
+			].join(":");
+			return !i.has(t) && (i.add(t), !0);
+		});
+	}
+};
+L = S([r(), x("design:paramtypes", [m === void 0 ? Object : m, E === void 0 ? Object : E])], L);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-nx/src/modules/instances/instances.module.ts
+var R = class {};
+R = S([i({
+	controllers: [],
+	exports: [L, D],
+	imports: [p, D],
+	providers: [L]
+})], R);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-nx/src/modules/options/options.constants.ts
+var fe = "@conformetry/nx", z = [
+	"conformetry.config.ts",
+	"conformetry.config.mts",
+	"conformetry.config.cts",
+	"conformetry.config.js",
+	"conformetry.config.mjs",
+	"conformetry.config.cjs",
+	"conformetry.config.json",
+	"conformetry.config.jsonc",
+	"conformetry.json",
+	"conformetry.jsonc",
+	".conformetryrc.ts",
+	".conformetryrc.js",
+	".conformetryrc.json",
+	"conformetryrc.ts",
+	"conformetryrc.js",
+	"conformetryrc.json"
+], B = "nx.json", pe = "conformetry-validate", me = ["configurationPath", "validateTargetName"], V = class {
+	constructor() {}
+	isUnknownArray(e) {
+		return Array.isArray(e);
+	}
+	readRegisteredConfigurationPath(e) {
+		if (typeof e != "object" || !e) return;
+		let { plugins: t } = { ...e };
+		if (this.isUnknownArray(t)) for (let e of t) {
+			if (typeof e != "object" || !e) continue;
+			let { options: t, plugin: n } = { ...e };
+			if (n === "@conformetry/nx") return typeof t == "object" && t ? this.readString({
+				key: "configurationPath",
+				options: { ...t }
+			}) : void 0;
+		}
+	}
+	readString(e) {
+		let t = e.options[e.key];
+		return typeof t == "string" && t !== "" ? t : void 0;
+	}
+	resolveConfigurationPath(e) {
+		return this.readRegisteredConfigurationPath(e.nxConfiguration) ?? z.find((t) => e.exists(t)) ?? z[0];
+	}
+	resolveGeneratorInputs(e) {
+		if (typeof e != "object" || !e) return {};
+		let t = {};
+		for (let [n, r] of Object.entries({ ...e })) me.includes(n) || typeof r != "string" || (t[n] = r);
+		return t;
+	}
+	resolvePluginOptions(e) {
+		if (typeof e != "object" || !e) return {
+			configurationPath: z[0],
+			validateTargetName: pe
+		};
+		let t = { ...e };
+		return {
+			configurationPath: this.readString({
+				key: "configurationPath",
+				options: t
+			}) ?? z[0],
+			validateTargetName: this.readString({
+				key: "validateTargetName",
+				options: t
+			}) ?? "conformetry-validate"
+		};
+	}
+};
+V = S([r(), x("design:paramtypes", [])], V);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-nx/src/modules/options/options.module.ts
+var H = class {};
+H = S([i({
+	controllers: [],
+	exports: [V],
+	imports: [],
+	providers: [V]
+})], H);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-nx/src/modules/paths/paths.service.ts
+var U = class {
+	instancesService;
+	configurationService;
+	scopeService;
+	constructor(e, t, n) {
+		this.instancesService = e, this.configurationService = t, this.scopeService = n;
+	}
+	requireModulePath(e) {
+		let t = this.resolveModulePath({
+			instances: e.instances,
+			moduleName: e.moduleName
+		});
+		if (t === void 0) throw Error(`Project ${e.projectName} has no module named ${e.moduleName}. Generate the module first, or name one of its existing modules.`);
+		return t;
+	}
+	resolveModuleParentPath(e) {
+		let t = /* @__PURE__ */ new Map();
+		console.log("instances", e.instances);
+		for (let n of e.instances) {
+			let r = n.path;
+			r.startsWith(e.projectRootPath + d.sep) && t.set(r, (t.get(r) ?? 0) + 1);
+		}
+		return console.log("countsByParent", [...t.entries()]), [...t.entries()].toSorted(([e, t], [n, r]) => r - t || e.localeCompare(n))[0]?.[0];
+	}
+	resolveModulePath(e) {
+		let t = e.instances.find((t) => t.nameStem === e.moduleName);
+		return t === void 0 ? void 0 : d.join(t.path, t.nameStem);
+	}
+	resolveNewProjectPath(e) {
+		return e.type === void 0 ? e.workspaceRoot : d.resolve(e.workspaceRoot, this.resolveTypeDirectoryPath({
+			tree: e.tree,
+			type: e.type
+		}) ?? e.type);
+	}
+	async resolveScopedDirectory(e) {
+		if (e.generatorName === void 0) return;
+		let t = (await this.configurationService.loadConformetryConfiguration(e.configurationPath)).find((t) => t.name === e.generatorName);
+		return t === void 0 ? void 0 : this.scopeService.resolveScopedDirectory(t.instances);
+	}
+	resolveTypeDirectoryPath(e) {
+		for (let [, t] of te(e.tree)) {
+			let [n] = t.root.split("/");
+			if (n === e.type) return n;
+		}
+	}
+	async resolveGenerationPath(e) {
+		let t = e.inputs[A];
+		if (t !== void 0) return d.resolve(e.workspaceRoot, t);
+		let n = e.inputs[O];
+		if (n === void 0) return this.resolveNewProjectPath({
+			tree: e.tree,
+			type: e.inputs[k],
+			workspaceRoot: e.workspaceRoot
+		});
+		let r = ne(e.tree, n), i = d.resolve(e.workspaceRoot, r.root), a = await this.instancesService.findProjectInstances({
+			configurationPath: e.configurationPath,
+			project: {
+				name: n,
+				root: r.root,
+				tags: r.tags ?? []
+			},
+			workspaceRoot: e.workspaceRoot
+		}), o = e.inputs[se];
+		if (o !== void 0) return this.requireModulePath({
+			instances: a,
+			moduleName: o,
+			projectName: e.inputs.project ?? ""
+		});
+		let s = await this.resolveScopedDirectory({
+			configurationPath: e.configurationPath,
+			generatorName: e.generatorName
+		});
+		return s === void 0 ? this.resolveModuleParentPath({
+			instances: a,
+			projectRootPath: i
+		}) ?? i : d.join(i, s);
+	}
+};
+U = S([r(), x("design:paramtypes", [
+	L === void 0 ? Object : L,
+	m === void 0 ? Object : m,
+	E === void 0 ? Object : E
+])], U);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-nx/src/modules/paths/paths.module.ts
+var W = class {};
+W = S([i({
+	controllers: [],
+	exports: [
+		R,
+		p,
+		U,
+		D
+	],
+	imports: [
+		R,
+		p,
+		D
+	],
+	providers: [U]
+})], W);
+var he = ".nxignore", G = class {
+	constructor() {}
+	isUnknownArray(e) {
+		return Array.isArray(e);
+	}
+	listProjectConfigurationFiles(e) {
+		let t = [];
+		for (let n of u(e.directoryPath, { withFileTypes: !0 })) {
+			let r = d.join(e.directoryPath, n.name), i = d.relative(e.workspaceRoot, r).split(d.sep).join("/");
+			if (n.isFile() && n.name === "project.json") {
+				t.push(i);
+				continue;
+			}
+			n.isDirectory() && !n.name.startsWith(".") && n.name !== "node_modules" && !e.ignoredPaths.includes(i) && t.push(...this.listProjectConfigurationFiles({
+				directoryPath: r,
+				ignoredPaths: e.ignoredPaths,
+				workspaceRoot: e.workspaceRoot
+			}));
+		}
+		return t;
+	}
+	readIgnoredPaths(e) {
+		let t = d.resolve(e, he);
+		return s(t) ? l(t, "utf8").split("\n").map((e) => e.trim()).filter((e) => e !== "" && !e.startsWith("#")) : [];
+	}
+	listWorkspaceProjects(e) {
+		return this.listProjectConfigurationFiles({
+			directoryPath: e,
+			ignoredPaths: this.readIgnoredPaths(e),
+			workspaceRoot: e
+		}).map((t) => this.readProjectScope({
+			projectConfigurationFile: t,
+			workspaceRoot: e
+		})).toSorted((e, t) => e.name.localeCompare(t.name));
+	}
+	readProjectScope(e) {
+		let t = d.dirname(e.projectConfigurationFile), n = JSON.parse(l(d.resolve(e.workspaceRoot, e.projectConfigurationFile), "utf8")), r = typeof n == "object" && n ? { ...n } : {}, i = this.isUnknownArray(r.tags) ? r.tags : [], a = typeof r.name == "string" ? r.name : t;
+		return {
+			name: a,
+			root: t,
+			tags: [...i.filter((e) => typeof e == "string"), `name:${a}`]
+		};
+	}
+};
+G = S([r(), x("design:paramtypes", [])], G);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-nx/src/modules/projects/projects.module.ts
+var K = class {};
+K = S([i({
+	controllers: [],
+	exports: [G],
+	imports: [],
+	providers: [G]
+})], K);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-nx/src/modules/plugin/plugin.constants.ts
+var ge = "**/{project.json,conformetry.config.*}", _e = "project.json", q = "__conformetryPluginContext", J, Y = J = class {
+	adapterService;
+	instancesService;
+	configurationService;
+	generatorService;
+	generationService;
+	optionsService;
+	pathsService;
+	projectsService;
+	reportingService;
+	validationService;
+	logger;
+	constructor(e, t, n, r, i, a, o, s, c, l, u) {
+		this.adapterService = e, this.instancesService = t, this.configurationService = n, this.generatorService = r, this.generationService = i, this.optionsService = a, this.pathsService = o, this.projectsService = s, this.reportingService = c, this.validationService = l, this.logger = u, this.logger.setContext(J.name);
+	}
+	async assertEmittedPluginCurrent(e) {
+		let t = await this.generatorService.emitPlugin({
+			configurationPath: e.configurationPath,
+			outputPath: j,
+			packageName: M,
+			projects: this.projectsService.listWorkspaceProjects(e.workspaceRoot)
+		});
+		for (let n of t) {
+			let t = d.resolve(e.workspaceRoot, n.filePath);
+			if ((s(t) ? l(t, "utf8") : void 0) !== n.content) throw this.logger.warn("🚫 Rejected a stale conformetry generator plugin", void 0, { filePath: n.filePath }), Error(`${n.filePath} is out of date with ${e.configurationPath}. Run \`nx sync\` to regenerate the conformetry generator plugin.`);
+		}
+	}
+	async assertPluginInSync(e) {
+		await this.assertTemplatesExist(e), await this.assertEmittedPluginCurrent(e);
+	}
+	async assertTemplatesExist(e) {
+		let t = await this.configurationService.loadConformetryConfiguration(e.configurationPath);
+		for (let n of t) {
+			let t = d.resolve(e.workspaceRoot, n.templatePath);
+			if (!s(t)) throw this.logger.warn("🚫 Rejected a generator with a missing template", void 0, {
+				generator: n.name,
+				templatePath: n.templatePath
+			}), Error(`Generator ${n.name} names a template at ${n.templatePath}, which does not exist.`);
+		}
+	}
+	readNxConfiguration(e) {
+		let t = d.resolve(e, B);
+		if (s(t)) return JSON.parse(l(t, "utf8"));
+	}
+	resolveOptions(e) {
+		let t = this.optionsService.resolveConfigurationPath({
+			exists: (t) => s(d.resolve(e.workspaceRoot, t)),
+			nxConfiguration: this.readNxConfiguration(e.workspaceRoot)
+		}), n = typeof e.options == "object" && e.options !== null ? { ...e.options } : {};
+		return this.optionsService.resolvePluginOptions({
+			configurationPath: t,
+			...n
+		});
+	}
+	async resolveTemplateInputs(e) {
+		let t = await this.configurationService.loadConformetryConfiguration(e.configurationPath);
+		return [...new Set(t.map((e) => e.templatePath))].map((e) => `{workspaceRoot}/${e}/**/*`);
+	}
+	async resolveTemplates(e) {
+		return (await this.configurationService.loadConformetryConfiguration(e.configurationPath)).map((t) => this.configurationService.collectTemplate({
+			name: t.name,
+			templatePath: d.resolve(e.workspaceRoot, t.templatePath),
+			threshold: t.threshold
+		}));
+	}
+	async inferTargets(e) {
+		let t = this.resolveOptions({
+			options: e.options,
+			workspaceRoot: e.workspaceRoot
+		}), n = await this.resolveTemplateInputs({ configurationPath: t.configurationPath }), r = /* @__PURE__ */ new Map();
+		for (let i of e.projectConfigurationFiles.filter((e) => d.basename(e) === _e)) {
+			let a = this.projectsService.readProjectScope({
+				projectConfigurationFile: i,
+				workspaceRoot: e.workspaceRoot
+			});
+			a.root !== "." && (await this.instancesService.findProjectInstances({
+				configurationPath: t.configurationPath,
+				project: a,
+				workspaceRoot: e.workspaceRoot
+			})).length !== 0 && r.set(a.root, { [t.validateTargetName]: {
+				cache: !0,
+				executor: `${fe}:validate`,
+				inputs: [
+					"default",
+					`{workspaceRoot}/${t.configurationPath}`,
+					`{workspaceRoot}/${j}/**/*`,
+					...n
+				],
+				options: {}
+			} });
+		}
+		return r;
+	}
+	async runGenerator(e) {
+		let t = this.resolveOptions({
+			options: e.options,
+			workspaceRoot: e.workspaceRoot
+		});
+		await this.assertPluginInSync({
+			configurationPath: t.configurationPath,
+			workspaceRoot: e.workspaceRoot
+		});
+		let n = await this.configurationService.loadConformetryConfiguration(t.configurationPath), r = n.find((t) => t.name === e.generatorName);
+		if (r === void 0) throw this.logger.error("🚫 Rejected an unknown generator", void 0, { generator: e.generatorName }), Error(`Unknown conformetry generator: ${e.generatorName}. Configured generators: ${n.map((e) => e.name).join(", ")}.`);
+		let i = this.adapterService.createAdapters({
+			tree: e.tree,
+			workspaceRoot: e.workspaceRoot
+		}), a = this.optionsService.resolveGeneratorInputs(e.options), { generatedFilePaths: o } = await this.generationService.runGenerator({
+			definition: {
+				name: r.name,
+				templateDirectoryPath: d.resolve(e.workspaceRoot, r.templatePath)
+			},
+			filesystem: i.filesystem,
+			formatter: i.formatter,
+			inputs: a,
+			instancePath: await this.pathsService.resolveGenerationPath({
+				configurationPath: t.configurationPath,
+				generatorName: e.generatorName,
+				inputs: a,
+				tree: e.tree,
+				workspaceRoot: e.workspaceRoot
+			})
+		});
+		return this.logger.info("✨ Generated instance files", void 0, {
+			count: o.length,
+			generator: e.generatorName
+		}), o;
+	}
+	async runValidation(e) {
+		let t = this.resolveOptions({
+			options: e.options,
+			workspaceRoot: e.workspaceRoot
+		});
+		await this.assertPluginInSync({
+			configurationPath: t.configurationPath,
+			workspaceRoot: e.workspaceRoot
+		});
+		let n = this.validationService.validate({
+			instances: await this.instancesService.findProjectInstances({
+				configurationPath: t.configurationPath,
+				project: e.project,
+				workspaceRoot: e.workspaceRoot
+			}),
+			...e.languageNames === void 0 ? {} : { languageNames: e.languageNames },
+			templates: await this.resolveTemplates({
+				configurationPath: t.configurationPath,
+				workspaceRoot: e.workspaceRoot
+			}),
+			...e.threshold === void 0 ? {} : { threshold: e.threshold }
+		});
+		return this.logger.info("👔 Validated conformetry instances", void 0, { ok: n.ok }), {
+			ok: n.ok,
+			report: this.reportingService.formatReport({
+				fileResults: n.fileResults,
+				scores: n.scores,
+				workingDirectory: e.workspaceRoot
+			})
+		};
+	}
+};
+Y = J = S([r(), x("design:paramtypes", [
+	F === void 0 ? Object : F,
+	L === void 0 ? Object : L,
+	m === void 0 ? Object : m,
+	N === void 0 ? Object : N,
+	g === void 0 ? Object : g,
+	V === void 0 ? Object : V,
+	U === void 0 ? Object : U,
+	G === void 0 ? Object : G,
+	v === void 0 ? Object : v,
+	b === void 0 ? Object : b,
+	w === void 0 ? Object : w
+])], Y);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-nx/src/modules/plugin/plugin.module.ts
+var X = class {};
+X = S([i({
+	controllers: [],
+	exports: [
+		I,
+		R,
+		p,
+		P,
+		h,
+		T,
+		H,
+		W,
+		Y,
+		K,
+		_,
+		D,
+		y
+	],
+	imports: [
+		I,
+		R,
+		p,
+		P,
+		h,
+		T,
+		H,
+		W,
+		K,
+		_,
+		D,
+		y
+	],
+	providers: [Y]
+})], X);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-nx/src/main.module.ts
+var Z = class {};
+Z = S([i({
+	controllers: [],
+	exports: [P, X],
+	imports: [
+		P,
+		T,
+		X
+	],
+	providers: []
+})], Z);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-nx/src/modules/plugin/plugin-context.utilities.ts
+async function Q() {
+	return (await $()).get(N);
+}
+async function ve() {
+	return (await $()).get(V);
+}
+async function ye() {
+	return (await $()).get(Y);
+}
+async function be() {
+	return (await $()).get(G);
+}
+async function $() {
+	let t = globalThis;
+	return t[q] ??= e.createApplicationContext(Z, {
+		abortOnError: !1,
+		logger: !1
+	}), await t[q];
+}
+//#endregion
+export { M as _, Z as a, E as b, ge as c, B as d, R as f, j as g, F as h, be as i, H as l, I as m, ve as n, X as o, L as p, ye as r, Y as s, Q as t, V as u, le as v, D as y };