@callidescope/configuration 0.0.0-stage → 0.0.1

package/dist/src/index.js

@@ -0,0 +1,900 @@
+import { z as e } from "zod";
+import { Injectable as t, Module as n } from "@nestjs/common";
+import r from "prompts";
+import { existsSync as i } from "node:fs";
+import { readFile as a } from "node:fs/promises";
+import o from "node:path";
+import { fileURLToPath as s } from "node:url";
+import { createJiti as c } from "jiti";
+import { parse as l } from "jsonc-parser";
+//#region packages/ic-suite/callidescope/callidescope-configuration/src/modules/configuration/configuration.constants.ts
+var u = [
+	"callidescope.config.ts",
+	"callidescope.config.mts",
+	"callidescope.config.cts",
+	"callidescope.config.js",
+	"callidescope.config.mjs",
+	"callidescope.config.cjs",
+	"callidescope.config.json",
+	"callidescope.config.jsonc"
+], d = /* @__PURE__ */ new Set([
+	".cjs",
+	".cts",
+	".js",
+	".json",
+	".jsonc",
+	".mjs",
+	".mts",
+	".ts"
+]), f = [".git", "pnpm-workspace.yaml"], p = [
+	"**/.conformetry/**",
+	"**/.nx/**",
+	"**/coverage/**",
+	"**/dist/**",
+	"**/node_modules/**",
+	"**/output/**"
+], ee = 6, m = [
+	"Command",
+	"Cron",
+	"Delete",
+	"Get",
+	"Mutation",
+	"OnEvent",
+	"Option",
+	"Patch",
+	"Post",
+	"Put",
+	"Query",
+	"ResolveField",
+	"SubscribeMessage"
+], te = 2, h = [
+	"markdown",
+	"mermaid",
+	"json"
+], g = "markdown", ne = "## 🔭 Callidescope", re = "# 🔭 Callidescope", ie = 3, ae = "<!-- callidescope:start -->", oe = "<!-- callidescope:end -->", _ = new Intl.ListFormat("en", {
+	style: "long",
+	type: "conjunction"
+}), se = (e) => typeof e.permission == "string" ? e.permission === "permitted" ? [e.field] : [] : Object.entries(e.permission).filter(([, e]) => e === "permitted").map(([t]) => `${e.field}.${t}`), v = {
+	directories: "forbidden",
+	entryPoints: "permitted",
+	exclude: "permitted",
+	excludeCallees: "forbidden",
+	excludeFrom: "forbidden",
+	limits: "permitted",
+	write: {
+		json: "forbidden",
+		markdown: "permitted",
+		mermaid: "permitted"
+	}
+}, ce = new Set(Object.entries(v).filter(([, e]) => typeof e != "string").map(([e]) => e)), y = new Set(Object.entries(v).flatMap(([e, t]) => se({
+	field: e,
+	permission: t
+}))), le = _.format(y), ue = {
+	entryPoints: [
+		"addresses",
+		"decorators",
+		"includeExportedFunctions",
+		"includeOrphans",
+		"includeTests"
+	],
+	exclude: [],
+	limits: ["maximumBreadth", "maximumDepth"],
+	write: ["markdown", "mermaid"]
+}, b = class extends Error {
+	constructor(e) {
+		super(`Unknown configuration file type: ${e}`), this.name = "UnknownConfigurationFileTypeError";
+	}
+}, x = () => e.custom((e) => typeof e == "function", { message: "Expected a function" }), de = e.strictObject({
+	maximumBreadth: e.number().int().positive().optional(),
+	maximumDepth: e.number().int().positive().optional()
+}).optional(), fe = e.strictObject({
+	addresses: e.array(e.string()).optional(),
+	decorators: e.array(e.string()).optional(),
+	includeExportedFunctions: e.boolean().optional(),
+	includeOrphans: e.boolean().optional(),
+	includeTests: e.boolean().optional()
+}).optional(), S = e.strictObject({
+	description: e.string().optional(),
+	endMarker: e.string().optional(),
+	heading: e.string().optional(),
+	path: e.string(),
+	previewCount: e.number().int().nonnegative().optional(),
+	render: x().optional(),
+	startMarker: e.string().optional(),
+	writeBlock: x().optional()
+}).optional(), pe = e.strictObject({
+	json: e.strictObject({
+		indentation: e.number().int().nonnegative().optional(),
+		path: e.string()
+	}).optional(),
+	markdown: S,
+	mermaid: S
+}).optional(), C = e.strictObject({
+	directories: e.array(e.string()).optional(),
+	entryPoints: fe,
+	exclude: e.array(e.string()).optional(),
+	excludeCallees: e.array(e.string()).optional(),
+	excludeFrom: e.array(e.string()).optional(),
+	ignoreCallees: e.never().optional(),
+	limits: de,
+	output: e.never().optional(),
+	write: pe
+}), w = class extends Error {
+	constructor(e) {
+		super(`Configuration file not found: ${e}`), this.name = "ConfigurationFileNotFoundError";
+	}
+}, T = class extends Error {
+	constructor(e) {
+		let t = e.cause instanceof Error ? e.cause.message : "It could not be read";
+		super(`Failed to read the callidescope configuration for ${e.project} at ${e.configurationPath}: ${t}`, { cause: e.cause }), this.name = "ProjectConfigurationError";
+	}
+}, E = class extends Error {
+	constructor(e) {
+		super(`${e.project} sets ${e.field}, which only the workspace configuration may set. A project configuration may set ${le}.`), this.name = "ProjectConfigurationFieldNotPermittedError";
+	}
+}, D = class extends Error {
+	constructor(e) {
+		super(`${e.project} leaves ${e.field} out of its callidescope configuration, which must be complete. Spread the workspace's projectDefaults and override what this project means to.`), this.name = "ProjectConfigurationIncompleteError";
+	}
+}, O = class extends Error {
+	constructor(e) {
+		super(`${e} is traced but has no callidescope.config.ts. Every traced project declares its own, spreading the workspace's projectDefaults and overriding what it means to.`), this.name = "ProjectConfigurationMissingError";
+	}
+}, k = class extends Error {
+	constructor(e) {
+		super(e), this.name = "InputError";
+	}
+}, A = (e) => new k(`${e} is required, and stdin is not a terminal so it cannot be asked for.`), j = (e) => new k(`${e} was not answered.`);
+//#endregion
+//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorateMetadata.js
+function M(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 N(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/ic-suite/callidescope/callidescope-configuration/src/modules/input/input.service.ts
+var P = class {
+	constructor() {}
+	promptRunner = r;
+	assertCanPrompt(e) {
+		if (!this.isAtTerminal()) throw A(e);
+	}
+	completeSuggestions(e) {
+		let t = e.input.trim(), n = e.suggestions.filter((e) => e.toLowerCase().includes(t.toLowerCase()));
+		return n.length === 0 && t.length > 0 ? [t] : n;
+	}
+	isAtTerminal() {
+		return process.stdin.isTTY;
+	}
+	parseCommaDelimitedOption(e) {
+		return e === void 0 ? [] : e.split(",").map((e) => e.trim()).filter(Boolean);
+	}
+	parseOptionalOption(e) {
+		let t = e?.trim();
+		return t === void 0 || t.length === 0 ? void 0 : t;
+	}
+	async promptForAutocompleteMultiselect(e) {
+		this.assertCanPrompt(e.subject);
+		let t = (await this.promptRunner({
+			choices: e.suggestions.map((e) => ({
+				title: e,
+				value: e
+			})),
+			message: e.message,
+			name: "value",
+			suggest: async (t) => await Promise.resolve(this.completeSuggestions({
+				input: t,
+				suggestions: e.suggestions
+			}).map((e) => ({
+				title: e,
+				value: e
+			}))),
+			type: "autocompleteMultiselect"
+		})).value;
+		if (!Array.isArray(t)) throw j(e.subject);
+		let n = t;
+		if (n.length === 0) throw j(e.subject);
+		let r = n.filter((e) => typeof e == "string");
+		if (r.length !== n.length) throw Error("Prompt resolved to something other than a list of text.");
+		return r;
+	}
+	async promptForSelect(e) {
+		this.assertCanPrompt(e.subject);
+		let t = (await this.promptRunner({
+			choices: e.choices.map((e) => ({
+				title: e,
+				value: e
+			})),
+			message: e.message,
+			name: "value",
+			type: "select"
+		})).value;
+		if (t === void 0) throw j(e.subject);
+		let n = e.choices.find((e) => e === t);
+		if (n === void 0) throw Error(`Prompt did not resolve to one of: ${e.choices.join(", ")}.`);
+		return n;
+	}
+};
+P = N([t(), M("design:paramtypes", [])], P);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-configuration/src/modules/input/input.module.ts
+var F = class {};
+F = N([n({
+	controllers: [],
+	exports: [P],
+	imports: [],
+	providers: [P]
+})], F);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-configuration/src/modules/flag-resolution/flag-resolution.constants.ts
+var me = (e) => `--format does not accept "${e}". It takes one of ${h.map((e) => `"${e}"`).join(", ")}.`, I = (e) => `${e.flag} overrides a destination the configuration does not declare. Add \`${e.field}\` to the configuration this run reads, then use ${e.flag} to send it somewhere else.`, L = (e) => `${e.flag} does not accept "${e.value}". It takes "true" or "false", or the flag on its own for "true".`, R = (e) => `${e.flag} does not accept "${e.value}". It takes a positive whole number.`, he = (e) => `${e.flag} overrides a value the configuration does not declare. Add \`${e.field}\` to the configuration this run reads, then use ${e.flag} to change it.`, z = (e) => new k(e.join(" ")), B = class {
+	constructor() {}
+	resolveCount(e) {
+		if (e.flagged === void 0) return;
+		if (e.configured === void 0) {
+			e.errors.push(he({
+				field: e.field,
+				flag: e.flag
+			}));
+			return;
+		}
+		let t = Number(e.flagged);
+		if (!Number.isInteger(t) || t <= 0) {
+			e.errors.push(R({
+				flag: e.flag,
+				value: e.flagged
+			}));
+			return;
+		}
+		return t;
+	}
+	resolveDestination(e) {
+		if (e.flagged === void 0) return e.configured;
+		if (e.configured === void 0) {
+			e.errors.push(I({
+				field: e.field,
+				flag: e.flag
+			}));
+			return;
+		}
+		return {
+			...e.configured,
+			path: e.flagged
+		};
+	}
+	resolveEntryPoints(e) {
+		let { configured: t, errors: n, flags: r } = e;
+		return {
+			addresses: this.resolveList({
+				configured: t.addresses,
+				flagged: r.entryPointAddresses
+			}),
+			decorators: this.resolveList({
+				configured: t.decorators,
+				flagged: r.entryPointDecorators
+			}),
+			includeExportedFunctions: this.resolveSwitch({
+				configured: t.includeExportedFunctions,
+				errors: n,
+				flag: "--include-exported-functions",
+				flagged: r.includeExportedFunctions
+			}),
+			includeOrphans: this.resolveSwitch({
+				configured: t.includeOrphans,
+				errors: n,
+				flag: "--include-orphans",
+				flagged: r.includeOrphans
+			}),
+			includeTests: this.resolveSwitch({
+				configured: t.includeTests,
+				errors: n,
+				flag: "--include-tests",
+				flagged: r.includeTests
+			})
+		};
+	}
+	resolveExclude(e) {
+		return e.flagged === void 0 || e.flagged.length === 0 ? e.configured : [.../* @__PURE__ */ new Set([...p, ...e.flagged])];
+	}
+	resolveFormat(e) {
+		if (e.flagged === void 0) return g;
+		let t = h.find((t) => t === e.flagged);
+		return t === void 0 ? (e.errors.push(me(e.flagged)), g) : t;
+	}
+	resolveLimitOverrides(e) {
+		let { configured: t, errors: n, flags: r } = e, i = {}, a = this.resolveCount({
+			configured: t.maximumBreadth,
+			errors: n,
+			field: "limits.maximumBreadth",
+			flag: "--maximum-breadth",
+			flagged: r.maximumBreadth
+		}), o = this.resolveCount({
+			configured: t.maximumDepth,
+			errors: n,
+			field: "limits.maximumDepth",
+			flag: "--maximum-depth",
+			flagged: r.maximumDepth
+		});
+		return a !== void 0 && (i.maximumBreadth = a), o !== void 0 && (i.maximumDepth = o), i;
+	}
+	resolveLimits(e) {
+		let { configured: t, overrides: n } = e, r = n.maximumBreadth ?? t.maximumBreadth, i = n.maximumDepth ?? t.maximumDepth;
+		return r === void 0 ? { maximumDepth: i } : {
+			maximumBreadth: r,
+			maximumDepth: i
+		};
+	}
+	resolveList(e) {
+		return e.flagged === void 0 || e.flagged.length === 0 ? e.configured : [...e.flagged];
+	}
+	resolveSwitch(e) {
+		return e.flagged === void 0 ? e.configured : e.flagged === !0 ? !0 : e.flagged === "true" || e.flagged === "false" ? e.flagged === "true" : (e.errors.push(L({
+			flag: e.flag,
+			value: e.flagged
+		})), e.configured);
+	}
+	resolveWrite(e) {
+		let { configured: t, errors: n, flags: r } = e;
+		return {
+			json: this.resolveDestination({
+				configured: t.json,
+				errors: n,
+				field: "write.json",
+				flag: "--json",
+				flagged: r.json
+			}),
+			markdown: this.resolveDestination({
+				configured: t.markdown,
+				errors: n,
+				field: "write.markdown",
+				flag: "--markdown",
+				flagged: r.markdown
+			}),
+			mermaid: this.resolveDestination({
+				configured: t.mermaid,
+				errors: n,
+				field: "write.mermaid",
+				flag: "--mermaid",
+				flagged: r.mermaid
+			})
+		};
+	}
+	resolveRunFlags(e) {
+		let { configuration: t, flags: n } = e, r = [], i = this.resolveFormat({
+			errors: r,
+			flagged: n.format
+		}), a = this.resolveLimitOverrides({
+			configured: t.limits,
+			errors: r,
+			flags: n
+		});
+		return {
+			configuration: {
+				...t,
+				directories: this.resolveList({
+					configured: t.directories,
+					flagged: n.directories
+				}),
+				entryPoints: this.resolveEntryPoints({
+					configured: t.entryPoints,
+					errors: r,
+					flags: n
+				}),
+				exclude: this.resolveExclude({
+					configured: t.exclude,
+					flagged: n.exclude
+				}),
+				excludeCallees: this.resolveList({
+					configured: t.excludeCallees,
+					flagged: n.excludeCallees
+				}),
+				limits: this.resolveLimits({
+					configured: t.limits,
+					overrides: a
+				}),
+				write: this.resolveWrite({
+					configured: t.write,
+					errors: r,
+					flags: n
+				})
+			},
+			errors: r,
+			format: i,
+			limitOverrides: a
+		};
+	}
+};
+B = N([t(), M("design:paramtypes", [])], B);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-configuration/src/modules/flag-resolution/flag-resolution.module.ts
+var V = class {};
+V = N([n({
+	controllers: [],
+	exports: [B],
+	imports: [],
+	providers: [B]
+})], V);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-configuration/src/modules/run-plan/run-plan.constants.ts
+var H = "breadth", U = "depth", W = "reports", G = [
+	H,
+	U,
+	W
+], ge = ",", K = [
+	"json",
+	"markdown",
+	"mermaid"
+], q = class {
+	flagResolutionService;
+	constructor(e) {
+		this.flagResolutionService = e;
+	}
+	describeAcceptedCheckNames(e) {
+		return `${e}. It takes a comma-separated set drawn from ${G.map((e) => `"${e}"`).join(" and ")}, as in "--check ${G.join(",")}".`;
+	}
+	readCheckNames(e, t) {
+		if (e === void 0) return /* @__PURE__ */ new Set();
+		if (e === !0) return t.push(this.describeAcceptedCheckNames("--check needs a value")), /* @__PURE__ */ new Set();
+		let n = e.split(",").map((e) => e.trim()).filter((e) => e !== "");
+		return n.length === 0 ? (t.push(this.describeAcceptedCheckNames("--check needs a value")), /* @__PURE__ */ new Set()) : this.validateCheckNames(n, t);
+	}
+	validateCheckNames(e, t) {
+		let n = /* @__PURE__ */ new Set();
+		for (let r of e) {
+			if (G.includes(r)) {
+				n.add(r);
+				continue;
+			}
+			t.push(this.describeAcceptedCheckNames(`--check does not accept "${r}"`));
+		}
+		return n;
+	}
+	async prepareLookup(e, t) {
+		let n = process.cwd(), { authored: r, configuration: i, path: a } = await t.loadConfigurationFile({
+			configurationPath: e.config,
+			searchDirectory: n
+		}), { configuration: o, errors: s, format: c } = this.flagResolutionService.resolveRunFlags({
+			configuration: i,
+			flags: {
+				directories: e.directories,
+				entryPointAddresses: e.entryPointAddresses,
+				entryPointDecorators: e.entryPointDecorators,
+				exclude: e.exclude,
+				excludeCallees: e.excludeCallees,
+				format: e.format,
+				includeExportedFunctions: e.includeExportedFunctions,
+				includeOrphans: e.includeOrphans,
+				includeTests: e.includeTests
+			}
+		});
+		if (s.length > 0) throw z(s);
+		return {
+			authoredLimits: r.limits,
+			configuration: o,
+			configurationPath: a,
+			format: c,
+			workspaceRoot: n
+		};
+	}
+	async prepareRun(e, t) {
+		let { errors: n, mode: r } = this.selectMode(e);
+		if (n.length > 0) return {
+			errors: n,
+			run: void 0
+		};
+		let i = process.cwd(), { authored: a, configuration: o, path: s } = await t.loadConfigurationFile({
+			configurationPath: e.config,
+			searchDirectory: i
+		}), { configuration: c, errors: l, format: u, limitOverrides: d } = this.flagResolutionService.resolveRunFlags({
+			configuration: o,
+			flags: {
+				check: e.check,
+				directories: e.directories,
+				entryPointAddresses: e.entryPointAddresses,
+				entryPointDecorators: e.entryPointDecorators,
+				exclude: e.exclude,
+				excludeCallees: e.excludeCallees,
+				format: e.format,
+				includeExportedFunctions: e.includeExportedFunctions,
+				includeOrphans: e.includeOrphans,
+				includeTests: e.includeTests,
+				json: e.json,
+				markdown: e.markdown,
+				maximumBreadth: e.maximumBreadth,
+				maximumDepth: e.maximumDepth,
+				mermaid: e.mermaid,
+				write: e.write
+			}
+		});
+		return l.length > 0 ? {
+			errors: l,
+			run: void 0
+		} : {
+			errors: l,
+			run: {
+				authoredLimits: a.limits,
+				configuration: c,
+				configurationPath: s,
+				format: u,
+				limitOverrides: d,
+				mode: r,
+				workspaceRoot: i
+			}
+		};
+	}
+	selectMode(e) {
+		let t = [], n = this.readCheckNames(e.check, t), r = e.write === !0;
+		r && n.has("reports") && t.push(`--write cannot be combined with --check ${W}: a report cannot be stale in the run that just wrote it. Drop one of them, or run --write and --check ${W} separately.`);
+		let i = K.filter((t) => e[t] !== void 0);
+		if (i.length > 0 && !r && !n.has("reports")) {
+			let e = i.length === 1;
+			t.push(`${i.map((e) => `--${e}`).join(" and ")} ${e ? "names a destination" : "name destinations"} but nothing writes or compares ${e ? "it" : "them"}. Add --write to write ${e ? "it" : "them"}, or --check ${W} to fail on ${e ? "it" : "them"} being out of date.`);
+		}
+		return {
+			errors: t,
+			mode: {
+				checksBreadth: n.has(H),
+				checksDepth: n.has(U),
+				checksReports: n.has(W),
+				writes: r
+			}
+		};
+	}
+	touchesFiles(e) {
+		return e.checksReports || e.writes;
+	}
+};
+q = N([t(), M("design:paramtypes", [B === void 0 ? Object : B])], q);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-configuration/src/modules/run-plan/run-plan.module.ts
+var J = class {};
+J = N([n({
+	controllers: [],
+	exports: [q],
+	imports: [V],
+	providers: [q]
+})], J);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-configuration/src/modules/configuration/configuration-file.service.ts
+var Y = class {
+	constructor() {}
+	findConfigurationFile(e) {
+		let t = o.resolve(e);
+		for (;;) {
+			let e = this.findConfigurationFileAt(t);
+			if (e !== void 0) return e;
+			let n = o.dirname(t);
+			if (n === t) return;
+			t = n;
+		}
+	}
+	findRepositoryRoot() {
+		let e = o.resolve(process.cwd());
+		for (;;) {
+			let t = e;
+			if (f.some((e) => i(o.join(t, e)))) return e;
+			let n = o.dirname(e);
+			if (n === e) return;
+			e = n;
+		}
+	}
+	async loadConfigurationModule(e) {
+		if (e.extension === ".json" || e.extension === ".jsonc") return this.loadJsonConfiguration(e);
+		let t = await c(s(import.meta.url)).import(e.configurationPath, { default: !0 });
+		if (typeof t != "object" || !t) return {};
+		let n = t.default;
+		return typeof n == "object" && n ? n : t;
+	}
+	async loadJsonConfiguration(e) {
+		let t = await a(e.configurationPath, "utf8");
+		return e.extension === ".jsonc" ? l(t) : JSON.parse(t);
+	}
+	resolveConfigurationPath(e) {
+		let t = o.resolve(e);
+		if (i(t)) return t;
+		let n = this.findRepositoryRoot();
+		if (n === void 0) throw new w(t);
+		let r = o.resolve(n, e);
+		if (!i(r)) throw new w(t);
+		return r;
+	}
+	resolveEntryPoints(e) {
+		let t = e ?? {};
+		return {
+			addresses: t.addresses ?? [],
+			decorators: t.decorators ?? [...m],
+			includeExportedFunctions: t.includeExportedFunctions ?? !0,
+			includeOrphans: t.includeOrphans ?? !0,
+			includeTests: t.includeTests ?? !1
+		};
+	}
+	resolveExclude(e) {
+		return [.../* @__PURE__ */ new Set([...p, ...e ?? []])];
+	}
+	resolveJsonOutput(e) {
+		if (e?.json !== void 0) return {
+			indentation: e.json.indentation ?? 2,
+			path: e.json.path
+		};
+	}
+	resolveLimits(e) {
+		let t = e ?? {};
+		return {
+			maximumBreadth: t.maximumBreadth,
+			maximumDepth: t.maximumDepth ?? 6
+		};
+	}
+	resolveMarkdownDestination(e) {
+		if (e !== void 0) return {
+			description: e.description,
+			endMarker: e.endMarker ?? "<!-- callidescope:end -->",
+			heading: e.heading ?? "# 🔭 Callidescope",
+			path: e.path,
+			previewCount: e.previewCount ?? 3,
+			render: e.render,
+			startMarker: e.startMarker ?? "<!-- callidescope:start -->",
+			writeBlock: e.writeBlock
+		};
+	}
+	findConfigurationFileAt(e) {
+		for (let t of u) {
+			let n = o.join(e, t);
+			if (i(n)) return n;
+		}
+	}
+	async loadConfiguration(e = {}) {
+		let { configuration: t } = await this.loadConfigurationFile(e);
+		return t;
+	}
+	async loadConfigurationFile(e = {}) {
+		let t = e.configurationPath === void 0 ? this.findConfigurationFile(e.searchDirectory ?? process.cwd()) : this.resolveConfigurationPath(e.configurationPath);
+		if (t === void 0) return {
+			authored: {},
+			configuration: this.resolveConfiguration({}),
+			path: void 0
+		};
+		let n = o.extname(t).toLowerCase();
+		if (!d.has(n)) throw new b(t);
+		let r = C.parse(await this.loadConfigurationModule({
+			configurationPath: t,
+			extension: n
+		}));
+		return {
+			authored: r,
+			configuration: this.resolveConfiguration(r),
+			path: t
+		};
+	}
+	resolveConfiguration(e) {
+		return {
+			directories: e.directories ?? [],
+			entryPoints: this.resolveEntryPoints(e.entryPoints),
+			exclude: this.resolveExclude(e.exclude),
+			excludeCallees: e.excludeCallees ?? [],
+			excludeFrom: e.excludeFrom ?? [],
+			limits: this.resolveLimits(e.limits),
+			write: {
+				json: this.resolveJsonOutput(e.write),
+				markdown: this.resolveMarkdownDestination(e.write?.markdown),
+				mermaid: this.resolveMarkdownDestination(e.write?.mermaid)
+			}
+		};
+	}
+};
+Y = N([t(), M("design:paramtypes", [])], Y);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-configuration/src/modules/configuration/configuration-file.module.ts
+var X = class {};
+X = N([n({
+	controllers: [],
+	exports: [Y],
+	imports: [],
+	providers: [Y]
+})], X);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-configuration/src/modules/configuration/project-configuration.service.ts
+var Z = class {
+	constructor() {}
+	assertComplete(e) {
+		let t = this.findMissingField(e.authored);
+		if (t !== void 0) throw new D({
+			field: t,
+			project: e.project
+		});
+	}
+	assertNoForbiddenFields(e) {
+		let t = this.findForbiddenField(e.authored);
+		if (t !== void 0) throw new E({
+			field: t,
+			project: e.project
+		});
+	}
+	buildProjectLimits(e) {
+		let { limits: t } = e.projectConfiguration.configuration;
+		return {
+			maximumBreadth: this.overrideLimit({
+				declared: t.maximumBreadth,
+				override: e.overrides?.maximumBreadth
+			}),
+			maximumDepth: this.overrideLimit({
+				declared: t.maximumDepth,
+				override: e.overrides?.maximumDepth
+			}) ?? t.maximumDepth,
+			path: e.projectConfiguration.path
+		};
+	}
+	buildWorkspaceLimits(e) {
+		let { maximumBreadth: t, maximumDepth: n } = e.workspaceConfiguration.limits, r = e.workspaceAuthoredLimits;
+		return {
+			maximumBreadth: t,
+			maximumDepth: n,
+			path: r?.maximumBreadth !== void 0 || r?.maximumDepth !== void 0 ? e.workspaceConfigurationPath : void 0
+		};
+	}
+	findForbiddenField(e) {
+		let t = { ...e };
+		for (let [e, n] of Object.entries(t)) {
+			if (n === void 0) continue;
+			let t = ce.has(e) ? this.findForbiddenMember({
+				field: e,
+				value: n
+			}) : this.readForbiddenField(e);
+			if (t !== void 0) return t;
+		}
+	}
+	findForbiddenMember(e) {
+		if (typeof e.value != "object" || e.value === null) return e.field;
+		let t = { ...e.value };
+		for (let [n, r] of Object.entries(t)) {
+			let t = `${e.field}.${n}`;
+			if (r !== void 0 && !y.has(t)) return t;
+		}
+	}
+	findMissingField(e) {
+		let t = { ...e };
+		for (let [e, n] of Object.entries(ue)) {
+			if (!(e in t)) return e;
+			let r = t[e];
+			if (n.length === 0) continue;
+			if (typeof r != "object" || !r) return e;
+			let i = n.find((e) => !(e in r));
+			if (i !== void 0) return `${e}.${i}`;
+		}
+	}
+	async loadProjectConfiguration(e) {
+		try {
+			let t = await e.reader.loadConfigurationFile({ configurationPath: e.configurationPath });
+			return {
+				authored: t.authored,
+				configuration: t.configuration,
+				path: t.path,
+				project: e.project
+			};
+		} catch (t) {
+			throw new T({
+				cause: t,
+				configurationPath: e.configurationPath,
+				project: e.project
+			});
+		}
+	}
+	overrideLimit(e) {
+		return e.declared === void 0 ? void 0 : e.override ?? e.declared;
+	}
+	readForbiddenField(e) {
+		return y.has(e) ? void 0 : e;
+	}
+	async loadProjectConfigurations(e, t) {
+		let n = e.workspaceConfigurationPath === void 0 ? void 0 : o.resolve(e.workspaceRoot, e.workspaceConfigurationPath), r = [];
+		for (let i of e.projects) {
+			let a = t.findConfigurationFileAt(o.resolve(e.workspaceRoot, i));
+			if (a === void 0) throw new O(i);
+			if (a === n) continue;
+			let s = await this.loadProjectConfiguration({
+				configurationPath: a,
+				project: i,
+				reader: t
+			});
+			this.assertNoForbiddenFields(s), this.assertComplete(s), r.push(s);
+		}
+		return r;
+	}
+	resolveLimits(e) {
+		let t = this.buildWorkspaceLimits(e), n = new Map(e.projectConfigurations.map((t) => [t.project, this.buildProjectLimits({
+			overrides: e.limitOverrides,
+			projectConfiguration: t
+		})]));
+		return {
+			byProject: new Map(e.projects.map((e) => [e, n.get(e) ?? t])),
+			workspace: t
+		};
+	}
+};
+Z = N([t(), M("design:paramtypes", [])], Z);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-configuration/src/modules/configuration/configuration.service.ts
+var Q = class {
+	configurationFileService;
+	inputService;
+	projectConfigurationService;
+	runPlanService;
+	constructor(e, t, n, r) {
+		this.configurationFileService = e, this.inputService = t, this.projectConfigurationService = n, this.runPlanService = r;
+	}
+	findConfigurationFileAt(e) {
+		return this.configurationFileService.findConfigurationFileAt(e);
+	}
+	async loadConfigurationFile(e = {}) {
+		return await this.configurationFileService.loadConfigurationFile(e);
+	}
+	async loadProjectConfigurations(e) {
+		return await this.projectConfigurationService.loadProjectConfigurations(e, this);
+	}
+	parseCommaDelimitedOption(e) {
+		return this.inputService.parseCommaDelimitedOption(e);
+	}
+	parseOptionalOption(e) {
+		return this.inputService.parseOptionalOption(e);
+	}
+	async prepareLookup(e) {
+		return await this.runPlanService.prepareLookup(e, this);
+	}
+	async prepareRun(e) {
+		return await this.runPlanService.prepareRun(e, this);
+	}
+	async promptForAutocompleteMultiselect(e) {
+		return await this.inputService.promptForAutocompleteMultiselect(e);
+	}
+	async promptForSelect(e) {
+		return await this.inputService.promptForSelect(e);
+	}
+	resolveConfiguration(e) {
+		return this.configurationFileService.resolveConfiguration(e);
+	}
+	async resolveFormatOption(e) {
+		if (e.format !== void 0 || !this.inputService.isAtTerminal()) return e;
+		let t = await this.promptForSelect({
+			choices: h,
+			message: "Which output format?",
+			subject: "An output format (--format)"
+		});
+		return {
+			...e,
+			format: t
+		};
+	}
+	resolveLimits(e) {
+		return this.projectConfigurationService.resolveLimits(e);
+	}
+	touchesFiles(e) {
+		return this.runPlanService.touchesFiles(e);
+	}
+};
+Q = N([t(), M("design:paramtypes", [
+	Y === void 0 ? Object : Y,
+	P === void 0 ? Object : P,
+	Z === void 0 ? Object : Z,
+	q === void 0 ? Object : q
+])], Q);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-configuration/src/modules/configuration/configuration.module.ts
+var $ = class {};
+$ = N([n({
+	controllers: [],
+	exports: [Q],
+	imports: [
+		X,
+		F,
+		J
+	],
+	providers: [Q, Z]
+})], $);
+//#endregion
+export { h as CALLIDESCOPE_OUTPUT_FORMATS, H as CHECK_BREADTH, U as CHECK_DEPTH, G as CHECK_NAMES, W as CHECK_REPORTS, ge as CHECK_SEPARATOR, u as CONFIGURATION_FILE_NAMES, w as ConfigurationFileNotFoundError, $ as ConfigurationModule, Q as ConfigurationService, m as DEFAULT_ENTRY_POINT_DECORATORS, p as DEFAULT_EXCLUDE_GLOBS, te as DEFAULT_JSON_INDENTATION, oe as DEFAULT_MARKDOWN_END_MARKER, ae as DEFAULT_MARKDOWN_START_MARKER, ee as DEFAULT_MAXIMUM_DEPTH, g as DEFAULT_OUTPUT_FORMAT, ie as DEFAULT_PREVIEW_COUNT, ne as DEFAULT_PROJECT_README_HEADING, re as DEFAULT_RUN_HEADING, K as DESTINATION_FLAG_NAMES, k as InputError, T as ProjectConfigurationError, E as ProjectConfigurationFieldNotPermittedError, D as ProjectConfigurationIncompleteError, O as ProjectConfigurationMissingError, f as REPOSITORY_ROOT_MARKERS, d as SUPPORTED_CONFIGURATION_EXTENSIONS, b as UnknownConfigurationFileTypeError, C as callidescopeConfigurationSchema, z as flagResolutionError, A as missingInputError, j as promptCancelledError };