@dialexjs/cli 0.0.0-stage → 0.1.0

package/dist/project-D4PmfqxM.mjs

@@ -0,0 +1,883 @@
+import fs from "node:fs";
+import path from "node:path";
+import fg from "fast-glob";
+import { resolveI18nConfig } from "dialexjs/scanner";
+import { generateCode, parseExpression, parseModule, writeFile } from "magicast";
+import { pathToFileURL } from "node:url";
+import { argumentSignature, findPlurals, isIcuStructured, parseMessage } from "dialexjs/icu";
+//#region src/utils/dictionary-edit.ts
+const TODO_PREFIX = "[TODO] ";
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+function unwrap(node) {
+	while (node && (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "ParenthesizedExpression")) node = node.expression;
+	return node;
+}
+const isObject = (node) => node?.type === "ObjectExpression";
+function keyName(prop) {
+	const key = prop?.key;
+	if (!key || prop.computed) return void 0;
+	if (key.type === "Identifier") return key.name;
+	if (key.type === "StringLiteral" || key.type === "Literal" && typeof key.value === "string") return key.value;
+	if (key.type === "NumericLiteral") return String(key.value);
+}
+const isPropLike = (p) => p?.type === "ObjectProperty" || p?.type === "Property" || p?.type === "ObjectMethod";
+function findProp(obj, key) {
+	return obj.properties.find((p) => isPropLike(p) && keyName(p) === key);
+}
+function stringValue(node) {
+	node = unwrap(node);
+	if (node?.type === "StringLiteral") return node.value;
+	if (node?.type === "Literal" && typeof node.value === "string") return node.value;
+	if (node?.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis[0]?.value?.cooked ?? void 0;
+}
+function leafKind(node) {
+	node = unwrap(node);
+	if (stringValue(node) !== void 0) return "string";
+	if (node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression" || node?.type === "ObjectMethod") return "function";
+	return "other";
+}
+function dictionaryProp(obj) {
+	const value = unwrap(findProp(obj, "dictionary")?.value);
+	return isObject(value) ? value : void 0;
+}
+function locateName(declaration) {
+	const decl = unwrap(declaration);
+	if (decl?.type === "CallExpression") {
+		const first = unwrap(decl.arguments[0]);
+		if (isObject(first)) return stringValue(findProp(first, "name")?.value);
+		return stringValue(first);
+	}
+	if (isObject(decl)) return stringValue(findProp(decl, "name")?.value);
+}
+function locateLocalesObject(declaration) {
+	const decl = unwrap(declaration);
+	if (decl?.type === "CallExpression") {
+		const first = unwrap(decl.arguments[0]);
+		const second = unwrap(decl.arguments[1]);
+		if (isObject(second)) return second;
+		if (isObject(first)) return dictionaryProp(first);
+		return;
+	}
+	if (isObject(decl)) return dictionaryProp(decl);
+}
+/** Quotes a property key only when it is not a valid identifier. */
+function keyCode(key) {
+	return IDENTIFIER.test(key) ? key : JSON.stringify(key);
+}
+/** Builds a detached `key: <value>` property node from source text. */
+function makeProp(key, valueCode) {
+	return parseExpression(`({ ${keyCode(key)}: ${valueCode} })`).$ast.properties[0];
+}
+function makeStringNode(value) {
+	return makeProp("_", JSON.stringify(value)).value;
+}
+/**
+* A dictionary is statically readable when every locale is an object literal and no object on the
+* way down uses spreads or computed keys.
+*/
+function isStaticallyComplete(localesObj) {
+	const walk = (obj) => obj.properties.every((prop) => {
+		if (!isPropLike(prop) || keyName(prop) === void 0) return false;
+		if (prop.type === "ObjectMethod") return true;
+		const value = unwrap(prop.value);
+		return isObject(value) ? walk(value) : true;
+	});
+	return localesObj.properties.every((prop) => {
+		if (!isPropLike(prop) || keyName(prop) === void 0 || prop.type === "ObjectMethod") return false;
+		const value = unwrap(prop.value);
+		return isObject(value) && walk(value);
+	});
+}
+/**
+* Parses dictionary source text (for example an unsaved editor buffer). Returns `undefined` when
+* the file does not have an editable shape; throws on syntax errors.
+*/
+function parseDictionaryText(file, text) {
+	const mod = parseModule(text);
+	const ast = mod.exports.default?.$ast;
+	if (!ast) return void 0;
+	const declaration = ast.declaration ?? ast;
+	const localesObj = locateLocalesObject(declaration);
+	return localesObj ? {
+		file,
+		mod,
+		localesObj,
+		name: locateName(declaration),
+		endsWithNewline: text.endsWith("\n"),
+		complete: isStaticallyComplete(localesObj)
+	} : void 0;
+}
+/** Loads a dictionary file; returns `undefined` when its shape is not editable. */
+async function loadDictionaryFile(file) {
+	return parseDictionaryText(file, fs.readFileSync(file, "utf-8"));
+}
+/** The source text with all edits applied, without writing anything. */
+function renderDictionaryFile(df) {
+	const code = generateCode(df.mod).code;
+	return df.endsWithNewline && !code.endsWith("\n") ? `${code}\n` : code;
+}
+async function saveDictionaryFile(df) {
+	await writeFile(df.mod, df.file);
+	if (df.endsWithNewline) {
+		const text = fs.readFileSync(df.file, "utf-8");
+		if (!text.endsWith("\n")) fs.writeFileSync(df.file, text + "\n", "utf-8");
+	}
+}
+function listLocales(df) {
+	return df.localesObj.properties.filter(isPropLike).map(keyName).filter((k) => k !== void 0);
+}
+function localeObject(df, locale) {
+	const value = unwrap(findProp(df.localesObj, locale)?.value);
+	return isObject(value) ? value : void 0;
+}
+/** Lists every leaf (string, function, or other value) of a locale, in source order. */
+function listLeaves(df, locale) {
+	const root = localeObject(df, locale);
+	if (!root) return [];
+	const leaves = [];
+	const walk = (obj, prefix) => {
+		for (const prop of obj.properties) {
+			if (!isPropLike(prop)) continue;
+			const name = keyName(prop);
+			if (name === void 0) continue;
+			const path = [...prefix, name];
+			const value = prop.type === "ObjectMethod" ? prop : unwrap(prop.value);
+			if (isObject(value)) walk(value, path);
+			else {
+				const kind = leafKind(value);
+				leaves.push({
+					path,
+					kind,
+					...kind === "string" ? { value: stringValue(value) } : {}
+				});
+			}
+		}
+	};
+	walk(root, []);
+	return leaves;
+}
+function getProp(df, locale, path) {
+	let obj = localeObject(df, locale);
+	for (let i = 0; obj && i < path.length; i++) {
+		const prop = findProp(obj, path[i]);
+		if (!prop) return void 0;
+		if (i === path.length - 1) return prop;
+		const next = unwrap(prop.value);
+		obj = isObject(next) ? next : void 0;
+	}
+}
+function hasPath(df, locale, path) {
+	return getProp(df, locale, path) !== void 0;
+}
+function getString(df, locale, path) {
+	const prop = getProp(df, locale, path);
+	return prop && prop.type !== "ObjectMethod" ? stringValue(prop.value) : void 0;
+}
+function ensureLocale(df, locale) {
+	let obj = localeObject(df, locale);
+	if (!obj) {
+		const prop = makeProp(locale, "{}");
+		df.localesObj.properties.push(prop);
+		obj = prop.value;
+	}
+	return obj;
+}
+/** Returns the object that should contain the last path segment, creating objects as needed. */
+function ensureParent(df, locale, path) {
+	let obj = ensureLocale(df, locale);
+	for (const segment of path.slice(0, -1)) {
+		let prop = findProp(obj, segment);
+		if (!prop) {
+			prop = makeProp(segment, "{}");
+			obj.properties.push(prop);
+		}
+		const next = unwrap(prop.value);
+		if (!isObject(next)) return void 0;
+		obj = next;
+	}
+	return obj;
+}
+/**
+* Sets a string value at `path`. Existing function or non-string values are left alone
+* (`"skipped"`) because they cannot be translated as plain text.
+*/
+function setString(df, locale, path, value) {
+	const parent = ensureParent(df, locale, path);
+	if (!parent) return "skipped";
+	const last = path[path.length - 1];
+	const existing = findProp(parent, last);
+	if (existing) {
+		if (existing.type === "ObjectMethod" || leafKind(existing.value) !== "string") return "skipped";
+		existing.value = makeStringNode(value);
+		return "updated";
+	}
+	parent.properties.push(makeProp(last, JSON.stringify(value)));
+	return "created";
+}
+/**
+* Copies the leaf at `path` from one locale to another. String values can be rewritten with
+* `mapString` (for example to add a `[TODO]` marker); other values are copied verbatim.
+* Returns `false` when the source has no such leaf or the target already has one.
+*/
+function copyLeaf(df, fromLocale, toLocale, path, mapString) {
+	const source = getProp(df, fromLocale, path);
+	if (!source || hasPath(df, toLocale, path)) return false;
+	const parent = ensureParent(df, toLocale, path);
+	if (!parent) return false;
+	const last = path[path.length - 1];
+	const text = source.type === "ObjectMethod" ? void 0 : stringValue(source.value);
+	if (text !== void 0 && mapString) parent.properties.push(makeProp(last, JSON.stringify(mapString(text))));
+	else {
+		const code = generateCode(source).code;
+		const expr = parseExpression(`({ ${code} })`);
+		parent.properties.push(expr.$ast.properties[0]);
+	}
+	return true;
+}
+/** Leaf paths of a runtime dictionary value (plain objects recurse; everything else is a leaf). */
+function flattenPaths(value, prefix = []) {
+	if (value && typeof value === "object" && !Array.isArray(value)) return Object.entries(value).flatMap(([k, v]) => flattenPaths(v, [...prefix, k]));
+	return prefix.length > 0 ? [prefix] : [];
+}
+const toRange = (loc) => loc ? {
+	start: {
+		line: loc.start.line - 1,
+		column: loc.start.column
+	},
+	end: {
+		line: loc.end.line - 1,
+		column: loc.end.column
+	}
+} : void 0;
+/**
+* Where a locale (no `path`) or a key within it is written. The range covers the property key, so
+* it is a good place to attach a diagnostic or jump to.
+*/
+function locationOf(df, locale, path = []) {
+	const prop = path.length === 0 ? findProp(df.localesObj, locale) : getProp(df, locale, path);
+	return toRange((prop?.key ?? prop)?.loc);
+}
+/** The source text of the dictionary object itself (the object whose keys are locales). */
+function dictionaryLocation(df) {
+	return toRange(df.localesObj.loc);
+}
+/** The source code of a leaf's value (a function's source, or a string with its quotes). */
+function getLeafSource(df, locale, path) {
+	const prop = getProp(df, locale, path);
+	if (!prop) return void 0;
+	return generateCode(prop.type === "ObjectMethod" ? prop : prop.value).code;
+}
+//#endregion
+//#region src/utils/icu-check.ts
+/** CLDR order. `resolvedOptions().pluralCategories` order differs between Node versions. */
+const CATEGORY_ORDER = [
+	"zero",
+	"one",
+	"two",
+	"few",
+	"many"
+];
+function requiredCategories(locale, ordinal) {
+	try {
+		return new Intl.PluralRules(locale, { type: ordinal ? "ordinal" : "cardinal" }).resolvedOptions().pluralCategories.filter((c) => c !== "other").sort((a, b) => CATEGORY_ORDER.indexOf(a) - CATEGORY_ORDER.indexOf(b));
+	} catch {
+		return [];
+	}
+}
+/**
+* Validates ICU messages across the locales of one dictionary:
+*
+* - invalid syntax: an error for messages that clearly use ICU (plural/select/number/date/time),
+*   a warning for plain `{placeholders}` that do not parse (they may not be meant as ICU);
+* - every locale must use the same arguments as the reference locale;
+* - plural options should cover the categories the locale's plural rules need.
+*/
+function checkIcu(dictionary, strings, defaultLocale) {
+	const findings = [];
+	const parsed = /* @__PURE__ */ new Map();
+	for (const [locale, entries] of strings) {
+		const ok = /* @__PURE__ */ new Map();
+		for (const [path, value] of entries) {
+			if (!value.includes("{")) continue;
+			const key = `${dictionary}.${path}`;
+			try {
+				ok.set(path, parseMessage(value));
+			} catch (error) {
+				const structured = isIcuStructured(value);
+				findings.push({
+					level: structured ? "error" : "warning",
+					code: "invalid-icu",
+					locale,
+					key,
+					message: structured ? `Invalid ICU message "${key}" (${locale}): ${error.message}` : `"${key}" (${locale}) contains braces but is not valid ICU, so t() values cannot be applied: ${error.message}`
+				});
+			}
+		}
+		parsed.set(locale, ok);
+	}
+	const order = [defaultLocale, ...[...parsed.keys()].filter((l) => l !== defaultLocale)];
+	const paths = new Set([...parsed.values()].flatMap((m) => [...m.keys()]));
+	for (const path of paths) {
+		const key = `${dictionary}.${path}`;
+		const reference = order.find((l) => parsed.get(l)?.has(path));
+		if (!reference) continue;
+		const expected = argumentSignature(parsed.get(reference).get(path));
+		for (const locale of order) {
+			const nodes = parsed.get(locale)?.get(path);
+			if (nodes && locale !== reference) {
+				const found = argumentSignature(nodes);
+				if (found !== expected) findings.push({
+					level: "error",
+					code: "icu-args-mismatch",
+					locale,
+					key,
+					message: `Locale "${locale}" uses different arguments than "${reference}" for "${key}" (expected ${expected || "none"}, found ${found || "none"})`
+				});
+			}
+			if (!nodes) continue;
+			for (const plural of findPlurals(nodes)) {
+				const missing = requiredCategories(locale, plural.ordinal).filter((c) => !(c in plural.options));
+				if (missing.length > 0) findings.push({
+					level: "warning",
+					code: "icu-plural-categories",
+					locale,
+					key,
+					message: `Locale "${locale}" plural "${plural.name}" in "${key}" has no ${missing.map((c) => `"${c}"`).join(", ")} option (used by this language; "other" will be shown instead)`
+				});
+			}
+		}
+	}
+	return findings;
+}
+//#endregion
+//#region src/analysis.ts
+const DICTIONARY_IGNORE = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/.next/**"
+];
+const DEFAULT_SOURCE_GLOB = "**/*.{ts,tsx,js,jsx,mjs,cjs,vue,svelte,astro,mdx}";
+const SOURCE_IGNORE = [
+	...DICTIONARY_IGNORE,
+	"**/.nuxt/**",
+	"**/.output/**",
+	"**/.svelte-kit/**",
+	"**/.astro/**",
+	"**/coverage/**",
+	"**/graphify-out/**",
+	"**/*.d.ts",
+	"**/i18n.generated.*",
+	"**/dialex.config.*",
+	"**/i18n.config.*"
+];
+/** `getDictionary("x")`, `useDictionary("x")`, `@I18nDictionary("x")` */
+const DICTIONARY_CALL = /\b(?:getDictionary|useDictionary|I18nDictionary)\(\s*(["'`])([^"'`$\n]+)\1/dg;
+/** `t("dictionary.path.to.key")` */
+const T_CALL = /(?<![\w$.])t\(\s*(["'`])([\w-]+(?:\.[\w-]+)+)\1/dg;
+/** Finds `getDictionary("x")`-style and `t("x.y.z")` references in source text. */
+function scanReferences(text) {
+	const references = [];
+	const collect = (pattern, kind) => {
+		for (const match of text.matchAll(pattern)) {
+			const [start, end] = match.indices[2];
+			references.push({
+				kind,
+				value: match[2],
+				start,
+				end
+			});
+		}
+	};
+	collect(DICTIONARY_CALL, "dictionary");
+	collect(T_CALL, "path");
+	return references.sort((a, b) => a.start - b.start);
+}
+function lineStarts(text) {
+	const starts = [0];
+	for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) starts.push(i + 1);
+	return starts;
+}
+function positionAt(starts, offset) {
+	let low = 0;
+	let high = starts.length - 1;
+	while (low < high) {
+		const mid = Math.ceil((low + high) / 2);
+		if (starts[mid] <= offset) low = mid;
+		else high = mid - 1;
+	}
+	return {
+		line: low,
+		column: offset - starts[low]
+	};
+}
+function fromSyntaxTree(df) {
+	const locales = listLocales(df);
+	const leaves = /* @__PURE__ */ new Map();
+	for (const locale of locales) {
+		const entries = /* @__PURE__ */ new Map();
+		for (const leaf of listLeaves(df, locale)) entries.set(leaf.path.join("."), {
+			kind: leaf.kind,
+			value: leaf.value
+		});
+		leaves.set(locale, entries);
+	}
+	return {
+		name: df.name,
+		locales,
+		leaves,
+		df
+	};
+}
+async function fromRuntime(file) {
+	try {
+		const mod = await import(`${pathToFileURL(file).href}?t=${Date.now()}_${Math.random()}`);
+		const definition = mod.default || mod;
+		if (!definition || typeof definition !== "object" || !definition.dictionary) return {
+			ok: false,
+			level: "error",
+			code: "invalid-dictionary",
+			message: "Default export does not appear to be a valid defineDictionary output."
+		};
+		const dictionary = definition.dictionary;
+		const leaves = /* @__PURE__ */ new Map();
+		const invalid = [];
+		for (const [locale, content] of Object.entries(dictionary)) {
+			if (!content || typeof content !== "object") {
+				invalid.push(locale);
+				continue;
+			}
+			const entries = /* @__PURE__ */ new Map();
+			for (const leafPath of flattenPaths(content)) {
+				let value = content;
+				for (const segment of leafPath) value = value?.[segment];
+				entries.set(leafPath.join("."), typeof value === "string" ? {
+					kind: "string",
+					value
+				} : { kind: typeof value === "function" ? "function" : "other" });
+			}
+			leaves.set(locale, entries);
+		}
+		if (invalid.length > 0) return {
+			ok: false,
+			level: "error",
+			code: "invalid-locale",
+			message: invalid.map((l) => `Locale "${l}" content is empty or invalid.`).join("\n")
+		};
+		return {
+			ok: true,
+			data: {
+				name: String(definition.name ?? ""),
+				locales: [...leaves.keys()],
+				leaves
+			}
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			level: "error",
+			code: "invalid-dictionary",
+			message: `Failed to import dictionary: ${error.message || String(error)}`
+		};
+	}
+}
+async function loadDictionaryData(file, runtime) {
+	let astError;
+	try {
+		const df = await loadDictionaryFile(file);
+		if (df?.complete && df.name) return {
+			ok: true,
+			data: fromSyntaxTree(df)
+		};
+	} catch (error) {
+		astError = error;
+	}
+	if (runtime) return fromRuntime(file);
+	return astError ? {
+		ok: false,
+		level: "error",
+		code: "invalid-dictionary",
+		message: `Failed to parse dictionary: ${astError.message}`
+	} : {
+		ok: false,
+		level: "info",
+		code: "unanalyzable",
+		message: "This dictionary uses spreads, computed keys, imported values, or a computed name, so it cannot be analyzed statically."
+	};
+}
+async function analyzeProject(options) {
+	const { root, config } = options;
+	const include = config.include || "**/*.content.ts";
+	const configuredLocales = config.locales || [];
+	const defaultLocale = config.defaultLocale || "en";
+	const extraIgnore = options.ignore ?? [];
+	const files = fg.sync(include, {
+		cwd: root,
+		absolute: true,
+		ignore: [...DICTIONARY_IGNORE, ...extraIgnore]
+	});
+	const issues = [];
+	const dictionaries = [];
+	for (const file of files) {
+		const loaded = await loadDictionaryData(file, options.runtime === true);
+		if (!loaded.ok) {
+			for (const message of loaded.message.split("\n")) issues.push({
+				file,
+				level: loaded.level,
+				code: loaded.code,
+				message
+			});
+			continue;
+		}
+		const { data } = loaded;
+		const { df } = data;
+		const at = (locale, keyPath) => df && locale ? locationOf(df, locale, keyPath) : void 0;
+		const add = (issue) => issues.push({
+			...issue,
+			file,
+			dictionary: data.name
+		});
+		for (const required of configuredLocales) if (!data.locales.includes(required)) add({
+			level: "error",
+			code: "missing-locale",
+			message: `Missing configured locale "${required}"`,
+			range: df ? dictionaryLocation(df) : void 0,
+			locale: required
+		});
+		const paths = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const locale of data.locales) for (const leafPath of data.leaves.get(locale).keys()) if (!seen.has(leafPath)) {
+			seen.add(leafPath);
+			paths.push(leafPath);
+		}
+		for (const locale of data.locales) {
+			const present = data.leaves.get(locale);
+			for (const leafPath of paths) {
+				if (present.has(leafPath)) continue;
+				const sourceLocale = [defaultLocale, ...data.locales].find((l) => l !== locale && data.leaves.get(l)?.has(leafPath));
+				add({
+					level: "error",
+					code: "missing-key",
+					message: `Locale "${locale}" is missing key "${leafPath}"`,
+					range: at(locale),
+					locale,
+					path: leafPath.split("."),
+					sourceLocale
+				});
+			}
+		}
+		const strings = /* @__PURE__ */ new Map();
+		for (const locale of data.locales) {
+			const entries = /* @__PURE__ */ new Map();
+			strings.set(locale, entries);
+			for (const [leafPath, leaf] of data.leaves.get(locale)) {
+				if (leaf.kind !== "string" || leaf.value === void 0) continue;
+				entries.set(leafPath, leaf.value);
+				if (leaf.value.startsWith("[TODO] ")) add({
+					level: "warning",
+					code: "todo-placeholder",
+					message: `Locale "${locale}" key "${leafPath}" still has a ${TODO_PREFIX.trim()} placeholder`,
+					range: at(locale, leafPath.split(".")),
+					locale,
+					path: leafPath.split(".")
+				});
+			}
+		}
+		for (const finding of checkIcu(data.name, strings, defaultLocale)) {
+			const keyPath = finding.key.slice(data.name.length + 1).split(".");
+			add({
+				level: finding.level,
+				code: finding.code,
+				message: finding.message,
+				range: at(finding.locale, keyPath),
+				locale: finding.locale,
+				path: keyPath
+			});
+		}
+		dictionaries.push({
+			name: data.name,
+			file,
+			locales: data.locales,
+			leaves: data.leaves,
+			paths,
+			df
+		});
+	}
+	const known = new Map(dictionaries.map((d) => [d.name, d]));
+	const dictionaryFiles = new Set(files);
+	const sourceGlobs = options.src ?? ["**/*.{ts,tsx,js,jsx,mjs,cjs,vue,svelte,astro,mdx}"];
+	const sourceFiles = sourceGlobs.length === 0 ? [] : fg.sync(sourceGlobs, {
+		cwd: root,
+		absolute: true,
+		ignore: [...SOURCE_IGNORE, ...extraIgnore]
+	}).filter((f) => !dictionaryFiles.has(f));
+	if (sourceFiles.length > 0) {
+		const tokens = /* @__PURE__ */ new Set();
+		for (const file of sourceFiles) {
+			let text;
+			try {
+				text = fs.readFileSync(file, "utf-8");
+			} catch {
+				continue;
+			}
+			for (const token of text.match(/[\w$-]+/g) ?? []) tokens.add(token);
+			const starts = lineStarts(text);
+			const rangeOf = (start, end) => ({
+				start: positionAt(starts, start),
+				end: positionAt(starts, end)
+			});
+			for (const ref of scanReferences(text)) {
+				if (ref.kind === "dictionary") {
+					if (!known.has(ref.value)) issues.push({
+						file,
+						level: "error",
+						code: "unknown-dictionary",
+						message: `Unknown dictionary "${ref.value}"`,
+						range: rangeOf(ref.start, ref.end),
+						dictionary: ref.value
+					});
+					continue;
+				}
+				const [name, ...rest] = ref.value.split(".");
+				const dictionary = known.get(name);
+				if (!dictionary) continue;
+				const keyPath = rest.join(".");
+				if (!dictionary.paths.some((p) => p === keyPath || p.startsWith(`${keyPath}.`))) issues.push({
+					file,
+					level: "error",
+					code: "unknown-path",
+					message: `Unknown translation path "${ref.value}"`,
+					range: rangeOf(ref.start, ref.end),
+					dictionary: name,
+					path: rest
+				});
+			}
+		}
+		if (options.unused !== false) for (const dictionary of dictionaries) {
+			if (!tokens.has(dictionary.name)) {
+				issues.push({
+					file: dictionary.file,
+					level: "warning",
+					code: "unused-dictionary",
+					message: `Dictionary "${dictionary.name}" is never referenced`,
+					range: dictionary.df ? dictionaryLocation(dictionary.df) : void 0,
+					dictionary: dictionary.name
+				});
+				continue;
+			}
+			for (const keyPath of dictionary.paths) {
+				const last = keyPath.split(".").pop();
+				if (tokens.has(last)) continue;
+				const holder = dictionary.locales.find((l) => dictionary.leaves.get(l)?.has(keyPath));
+				issues.push({
+					file: dictionary.file,
+					level: "warning",
+					code: "unused-key",
+					message: `Key "${keyPath}" is possibly unused`,
+					range: dictionary.df && holder ? locationOf(dictionary.df, holder, keyPath.split(".")) : void 0,
+					dictionary: dictionary.name,
+					path: keyPath.split(".")
+				});
+			}
+		}
+	}
+	return {
+		issues,
+		dictionaries,
+		files,
+		sourceFilesScanned: sourceFiles.length
+	};
+}
+/** Project root-relative path with forward slashes, for display. */
+function relativeFile(root, file) {
+	return path.relative(root, file);
+}
+//#endregion
+//#region src/utils/static-config.ts
+const CONFIG_NAMES = ["dialex.config", "i18n.config"];
+const EXTENSIONS = [
+	"ts",
+	"mts",
+	"cts",
+	"js",
+	"mjs",
+	"cjs",
+	"json"
+];
+const DEFAULT_STATIC_CONFIG = {
+	defaultLocale: "en",
+	locales: [],
+	include: "**/*.content.ts",
+	fallbacks: {},
+	prefixDefault: true,
+	lazy: false
+};
+const NOT_LITERAL = Symbol("not literal");
+function literal(node) {
+	node = unwrap(node);
+	switch (node?.type) {
+		case "StringLiteral":
+		case "NumericLiteral":
+		case "BooleanLiteral": return node.value;
+		case "Literal": return node.value;
+		case "TemplateLiteral": return node.expressions.length === 0 ? node.quasis[0]?.value?.cooked ?? "" : NOT_LITERAL;
+		case "ArrayExpression": {
+			const items = node.elements.map((e) => literal(e));
+			return items.includes(NOT_LITERAL) ? NOT_LITERAL : items;
+		}
+		case "ObjectExpression": {
+			const result = {};
+			for (const prop of node.properties) {
+				const key = keyName(prop);
+				const value = key === void 0 ? NOT_LITERAL : literal(prop.value);
+				if (value === NOT_LITERAL) return NOT_LITERAL;
+				result[key] = value;
+			}
+			return result;
+		}
+		default: return NOT_LITERAL;
+	}
+}
+/** The object literal passed to `defineConfig({...})`, or exported directly. */
+function findConfigObject(declaration) {
+	const node = unwrap(declaration);
+	if (node?.type === "CallExpression") return findConfigObject(node.arguments[0]);
+	return isObject(node) ? node : void 0;
+}
+const isStringArray = (value) => Array.isArray(value) && value.every((v) => typeof v === "string");
+function apply(object, config, notes) {
+	const accept = (key, valid, expected) => {
+		if (!(key in object)) return;
+		const value = object[key];
+		if (valid(value)) config[key] = value;
+		else notes.push(`"${key}" could not be read statically (expected ${expected}).`);
+	};
+	accept("defaultLocale", (v) => typeof v === "string" && v !== "", "a string literal");
+	accept("locales", isStringArray, "an array of string literals");
+	accept("include", (v) => typeof v === "string" || isStringArray(v), "a string or array of strings");
+	accept("fallbacks", (v) => typeof v === "object" && v !== null && Object.values(v).every((list) => isStringArray(list)), "an object of string arrays");
+	accept("prefixDefault", (v) => typeof v === "boolean", "true or false");
+	accept("lazy", (v) => typeof v === "boolean", "true or false");
+}
+/** Reads a config file's source text. Exposed for tests and for unsaved buffers. */
+function parseStaticConfig(text, file = "dialex.config.ts") {
+	const notes = [];
+	const config = { ...DEFAULT_STATIC_CONFIG };
+	if (file.endsWith(".json")) {
+		try {
+			const data = JSON.parse(text);
+			if (data && typeof data === "object") apply(data, config, notes);
+		} catch (error) {
+			notes.push(`Could not parse ${path.basename(file)}: ${error.message}`);
+		}
+		return {
+			config,
+			file,
+			notes
+		};
+	}
+	try {
+		const exported = parseModule(text).exports.default;
+		const object = findConfigObject(exported?.$ast?.declaration ?? exported?.$ast);
+		if (!object) notes.push(`${path.basename(file)} does not export a config object literal.`);
+		else {
+			const values = {};
+			for (const key of [
+				"defaultLocale",
+				"locales",
+				"include",
+				"fallbacks",
+				"prefixDefault",
+				"lazy"
+			]) {
+				const prop = findProp(object, key);
+				if (!prop) continue;
+				const value = literal(prop.value);
+				if (value === NOT_LITERAL) notes.push(`"${key}" could not be read statically (not a literal).`);
+				else values[key] = value;
+			}
+			apply(values, config, notes);
+		}
+	} catch (error) {
+		notes.push(`Could not parse ${path.basename(file)}: ${error.message}`);
+	}
+	return {
+		config,
+		file,
+		notes
+	};
+}
+/** Reads `dialex.config.*` (or `i18n.config.*`) from `root`, or from `configFile` if given. */
+function readStaticConfig(root, configFile) {
+	const candidates = configFile ? [path.resolve(root, configFile)] : CONFIG_NAMES.flatMap((name) => EXTENSIONS.map((ext) => path.join(root, `${name}.${ext}`)));
+	for (const file of candidates) if (fs.existsSync(file)) return parseStaticConfig(fs.readFileSync(file, "utf-8"), file);
+	return {
+		config: { ...DEFAULT_STATIC_CONFIG },
+		notes: []
+	};
+}
+//#endregion
+//#region src/utils/project.ts
+async function loadDictionaries(root, config) {
+	const include = config.include || "**/*.content.ts";
+	const files = fg.sync(include, {
+		cwd: root,
+		absolute: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/.next/**"
+		]
+	});
+	const dictionaries = [];
+	const unsupported = [];
+	for (const file of files) {
+		const rel = path.relative(root, file);
+		try {
+			const df = await loadDictionaryFile(file);
+			if (!df || !df.name) unsupported.push(rel);
+			else dictionaries.push({
+				rel,
+				name: df.name,
+				df
+			});
+		} catch {
+			unsupported.push(rel);
+		}
+	}
+	return {
+		dictionaries,
+		unsupported
+	};
+}
+/**
+* Resolves the config (running `dialex.config.*` through the loader, which executes it) and loads
+* every dictionary file for AST-level reading and editing.
+*/
+async function loadProject(root, configFile) {
+	const config = resolveI18nConfig(root, configFile ? { configFile } : {});
+	return {
+		root,
+		config,
+		notes: [],
+		...await loadDictionaries(root, config)
+	};
+}
+/**
+* Like `loadProject`, but reads the config from the syntax tree without executing it. Use this in
+* editors and anywhere project code must not run.
+*/
+async function loadStaticProject(root, configFile) {
+	const { config, notes } = readStaticConfig(root, configFile);
+	return {
+		root,
+		config,
+		notes,
+		...await loadDictionaries(root, config)
+	};
+}
+/** `home` + `["nav", "about"]` -> `home.nav.about` */
+const toKey = (dictionary, keyPath) => [dictionary, ...keyPath].join(".");
+//#endregion
+export { saveDictionaryFile as C, renderDictionaryFile as S, listLeaves as _, parseStaticConfig as a, locationOf as b, analyzeProject as c, TODO_PREFIX as d, copyLeaf as f, hasPath as g, getString as h, DEFAULT_STATIC_CONFIG as i, relativeFile as l, getLeafSource as m, loadStaticProject as n, readStaticConfig as o, dictionaryLocation as p, toKey as r, DEFAULT_SOURCE_GLOB as s, loadProject as t, scanReferences as u, listLocales as v, setString as w, parseDictionaryText as x, loadDictionaryFile as y };
+
+//# sourceMappingURL=project-D4PmfqxM.mjs.map