@vocab/core 1.6.4 → 1.6.5-fix-messageformat-import-20250923014407

package/dist/index.js

@@ -0,0 +1,679 @@
+const require_chunk = require('./chunk-nOFOJqeH.js');
+let intl_messageformat = require("intl-messageformat");
+intl_messageformat = require_chunk.__toESM(intl_messageformat);
+let fs = require("fs");
+fs = require_chunk.__toESM(fs);
+let path = require("path");
+path = require_chunk.__toESM(path);
+let __formatjs_icu_messageformat_parser = require("@formatjs/icu-messageformat-parser");
+__formatjs_icu_messageformat_parser = require_chunk.__toESM(__formatjs_icu_messageformat_parser);
+let prettier = require("prettier");
+prettier = require_chunk.__toESM(prettier);
+let chokidar = require("chokidar");
+chokidar = require_chunk.__toESM(chokidar);
+let picocolors = require("picocolors");
+picocolors = require_chunk.__toESM(picocolors);
+let debug = require("debug");
+debug = require_chunk.__toESM(debug);
+let fast_glob = require("fast-glob");
+fast_glob = require_chunk.__toESM(fast_glob);
+let __formatjs_icu_messageformat_parser_printer_js = require("@formatjs/icu-messageformat-parser/printer.js");
+__formatjs_icu_messageformat_parser_printer_js = require_chunk.__toESM(__formatjs_icu_messageformat_parser_printer_js);
+let find_up = require("find-up");
+find_up = require_chunk.__toESM(find_up);
+let fastest_validator = require("fastest-validator");
+fastest_validator = require_chunk.__toESM(fastest_validator);
+
+//#region src/logger.ts
+const trace = (0, debug.default)(`vocab:core`);
+
+//#endregion
+//#region src/utils.ts
+const defaultTranslationDirSuffix = ".vocab";
+const devTranslationFileName = "translations.json";
+const globAnyPathWithOptionalPrefix = "**/?(*)";
+function isDevLanguageFile(filePath) {
+	return filePath.endsWith(`/${devTranslationFileName}`) || filePath === devTranslationFileName;
+}
+function isAltLanguageFile(filePath) {
+	return filePath.endsWith(".translations.json");
+}
+function isTranslationDirectory(filePath, { translationsDirectorySuffix = defaultTranslationDirSuffix }) {
+	return filePath.endsWith(translationsDirectorySuffix);
+}
+function getTranslationFolderGlob({ translationsDirectorySuffix = defaultTranslationDirSuffix }) {
+	const result = `${globAnyPathWithOptionalPrefix}${translationsDirectorySuffix}`;
+	trace("getTranslationFolderGlob", result);
+	return result;
+}
+function getDevTranslationFileGlob({ translationsDirectorySuffix = defaultTranslationDirSuffix }) {
+	const result = `${globAnyPathWithOptionalPrefix}${translationsDirectorySuffix}/${devTranslationFileName}`;
+	trace("getDevTranslationFileGlob", result);
+	return result;
+}
+function getAltTranslationFileGlob(config) {
+	const altLanguages = getAltLanguages(config);
+	const langMatch = altLanguages.length === 1 ? altLanguages[0] : `{${altLanguages.join(",")}}`;
+	const { translationsDirectorySuffix = defaultTranslationDirSuffix } = config;
+	const result = `**/*${translationsDirectorySuffix}/${langMatch}.translations.json`;
+	trace("getAltTranslationFileGlob", result);
+	return result;
+}
+function getAltLanguages({ devLanguage, languages }) {
+	return languages.map((v) => v.name).filter((lang) => lang !== devLanguage);
+}
+function getDevLanguageFileFromTsFile(tsFilePath) {
+	const directory = path.default.dirname(tsFilePath);
+	const result = path.default.normalize(path.default.join(directory, devTranslationFileName));
+	trace(`Returning dev language path ${result} for path ${tsFilePath}`);
+	return result;
+}
+function getDevLanguageFileFromAltLanguageFile(altLanguageFilePath) {
+	const directory = path.default.dirname(altLanguageFilePath);
+	const result = path.default.normalize(path.default.join(directory, devTranslationFileName));
+	trace(`Returning dev language path ${result} for path ${altLanguageFilePath}`);
+	return result;
+}
+function getTSFileFromDevLanguageFile(devLanguageFilePath) {
+	const directory = path.default.dirname(devLanguageFilePath);
+	const result = path.default.normalize(path.default.join(directory, "index.ts"));
+	trace(`Returning TS path ${result} for path ${devLanguageFilePath}`);
+	return result;
+}
+function getAltLanguageFilePath(devLanguageFilePath, language) {
+	const directory = path.default.dirname(devLanguageFilePath);
+	const result = path.default.normalize(path.default.join(directory, `${language}.translations.json`));
+	trace(`Returning alt language path ${result} for path ${devLanguageFilePath}`);
+	return path.default.normalize(result);
+}
+function mapValues(obj, func) {
+	const newObj = {};
+	const keys = Object.keys(obj);
+	for (const key of keys) newObj[key] = func(obj[key]);
+	return newObj;
+}
+function getTranslationMessages(translations) {
+	return mapValues(translations, (v) => v.message);
+}
+
+//#endregion
+//#region src/generate-language.ts
+function generateLanguageFromTranslations({ baseTranslations, generator }) {
+	if (!generator.transformElement && !generator.transformMessage) return baseTranslations;
+	const translationKeys = Object.keys(baseTranslations);
+	const generatedTranslations = {};
+	for (const translationKey of translationKeys) {
+		const translation = baseTranslations[translationKey];
+		let transformedMessage = translation.message;
+		if (generator.transformElement) {
+			const transformedAst = new intl_messageformat.IntlMessageFormat(translation.message).getAst().map(transformMessageFormatElement(generator.transformElement));
+			transformedMessage = (0, __formatjs_icu_messageformat_parser_printer_js.printAST)(transformedAst);
+		}
+		if (generator.transformMessage) transformedMessage = generator.transformMessage(transformedMessage);
+		generatedTranslations[translationKey] = { message: transformedMessage };
+	}
+	return generatedTranslations;
+}
+function transformMessageFormatElement(transformElement) {
+	return (messageFormatElement) => {
+		const transformedMessageFormatElement = { ...messageFormatElement };
+		switch (transformedMessageFormatElement.type) {
+			case __formatjs_icu_messageformat_parser.TYPE.literal:
+				transformedMessageFormatElement.value = transformElement(transformedMessageFormatElement.value);
+				break;
+			case __formatjs_icu_messageformat_parser.TYPE.select:
+			case __formatjs_icu_messageformat_parser.TYPE.plural:
+				const transformedOptions = { ...transformedMessageFormatElement.options };
+				for (const key of Object.keys(transformedOptions)) transformedOptions[key].value = transformedOptions[key].value.map(transformMessageFormatElement(transformElement));
+				break;
+			case __formatjs_icu_messageformat_parser.TYPE.tag:
+				transformedMessageFormatElement.children = transformedMessageFormatElement.children.map(transformMessageFormatElement(transformElement));
+				break;
+			default: break;
+		}
+		return transformedMessageFormatElement;
+	};
+}
+
+//#endregion
+//#region src/load-translations.ts
+function getUniqueKey(key, namespace) {
+	return `${key}.${namespace}`;
+}
+function mergeWithDevLanguageTranslation({ translation, devTranslation }) {
+	const keys = Object.keys(devTranslation);
+	const newLanguage = {};
+	for (const key of keys) if (translation[key]) newLanguage[key] = {
+		message: translation[key].message,
+		description: devTranslation[key].description
+	};
+	return newLanguage;
+}
+function getLanguageFallbacks({ languages }) {
+	const languageFallbackMap = /* @__PURE__ */ new Map();
+	for (const lang of languages) if (lang.extends) languageFallbackMap.set(lang.name, lang.extends);
+	return languageFallbackMap;
+}
+function getLanguageHierarchy({ languages }) {
+	const hierarchyMap = /* @__PURE__ */ new Map();
+	const fallbacks = getLanguageFallbacks({ languages });
+	for (const lang of languages) {
+		const langHierarchy = [];
+		let currLang = lang.extends;
+		while (currLang) {
+			langHierarchy.push(currLang);
+			currLang = fallbacks.get(currLang);
+		}
+		hierarchyMap.set(lang.name, langHierarchy);
+	}
+	return hierarchyMap;
+}
+function getFallbackLanguageOrder({ languages, languageName, devLanguage, fallbacks }) {
+	const languageHierarchy = getLanguageHierarchy({ languages }).get(languageName);
+	if (!languageHierarchy) throw new Error(`Missing language hierarchy for ${languageName}`);
+	const fallbackLanguageOrder = [languageName];
+	if (fallbacks !== "none") {
+		fallbackLanguageOrder.unshift(...languageHierarchy.reverse());
+		if (fallbacks === "all" && fallbackLanguageOrder[0] !== devLanguage) fallbackLanguageOrder.unshift(devLanguage);
+	}
+	return fallbackLanguageOrder;
+}
+function getNamespaceByFilePath(relativePath, { translationsDirectorySuffix = defaultTranslationDirSuffix }) {
+	let namespace = path.default.dirname(relativePath).replace(/^src\//, "").replace(/\//g, "_");
+	if (namespace.endsWith(translationsDirectorySuffix)) namespace = namespace.slice(0, -translationsDirectorySuffix.length);
+	return namespace;
+}
+function printValidationError(...params) {
+	console.error(picocolors.default.red("Error loading translation:"), ...params);
+}
+function getTranslationsFromFile(translationFileContents, { isAltLanguage, filePath, withTags }) {
+	if (!translationFileContents || typeof translationFileContents !== "object") throw new Error(`Unable to read translation file ${filePath}. Translations must be an object.`);
+	const { $namespace, _meta,...keys } = translationFileContents;
+	if (isAltLanguage && $namespace) printValidationError(`Found $namespace in alt language file in ${filePath}. $namespace is only used in the dev language and will be ignored.`);
+	if (!isAltLanguage && $namespace && typeof $namespace !== "string") printValidationError(`Found non-string $namespace in language file in ${filePath}. $namespace must be a string.`);
+	if (isAltLanguage && _meta?.tags) printValidationError(`Found _meta.tags in alt language file in ${filePath}. _meta.tags is only used in the dev language and will be ignored.`);
+	const includeTags = !isAltLanguage && withTags;
+	const validKeys = {};
+	for (const [translationKey, { tags,...translation }] of Object.entries(keys)) {
+		if (typeof translation === "string") {
+			printValidationError(`Found string for a translation "${translationKey}" in ${filePath}. Translation must be an object of the format {message: string}.`);
+			continue;
+		}
+		if (!translation) {
+			printValidationError(`Found empty translation "${translationKey}" in ${filePath}. Translation must be an object of the format {message: string}.`);
+			continue;
+		}
+		if (!translation.message || typeof translation.message !== "string") {
+			printValidationError(`No message found for translation "${translationKey}" in ${filePath}. Translation must be an object of the format {message: string}.`);
+			continue;
+		}
+		validKeys[translationKey] = {
+			...translation,
+			tags: includeTags ? tags : void 0
+		};
+	}
+	const metadata = { tags: includeTags ? _meta?.tags : void 0 };
+	return {
+		$namespace,
+		keys: validKeys,
+		metadata
+	};
+}
+function loadAltLanguageFile({ filePath, languageName, devTranslation, fallbacks }, { devLanguage, languages }) {
+	const altLanguageTranslation = {};
+	const fallbackLanguageOrder = getFallbackLanguageOrder({
+		languages,
+		languageName,
+		devLanguage,
+		fallbacks
+	});
+	trace(`Loading alt language file with precedence: ${fallbackLanguageOrder.slice().reverse().join(" -> ")}`);
+	for (const fallbackLanguage of fallbackLanguageOrder) if (fallbackLanguage !== devLanguage) try {
+		const altFilePath = getAltLanguageFilePath(filePath, fallbackLanguage);
+		delete require.cache[altFilePath];
+		const translationFile = require(altFilePath);
+		const { keys: fallbackLanguageTranslation } = getTranslationsFromFile(translationFile, {
+			filePath: altFilePath,
+			isAltLanguage: true
+		});
+		Object.assign(altLanguageTranslation, mergeWithDevLanguageTranslation({
+			translation: fallbackLanguageTranslation,
+			devTranslation
+		}));
+	} catch {
+		trace(`Missing alt language file ${getAltLanguageFilePath(filePath, fallbackLanguage)}
+        `);
+	}
+	else Object.assign(altLanguageTranslation, devTranslation);
+	return altLanguageTranslation;
+}
+function stripTagsFromTranslations(translations) {
+	return Object.fromEntries(Object.entries(translations).map(([key, { tags,...rest }]) => [key, rest]));
+}
+function loadTranslation({ filePath, fallbacks, withTags }, userConfig) {
+	trace(`Loading translation file in "${fallbacks}" fallback mode: "${filePath}"`);
+	const languageSet = {};
+	delete require.cache[filePath];
+	const translationContent = require(filePath);
+	const relativePath = path.default.relative(userConfig.projectRoot || process.cwd(), filePath);
+	const { $namespace, keys: devTranslation, metadata } = getTranslationsFromFile(translationContent, {
+		filePath,
+		isAltLanguage: false,
+		withTags
+	});
+	const namespace = typeof $namespace === "string" ? $namespace : getNamespaceByFilePath(relativePath, userConfig);
+	trace(`Found file ${filePath}. Using namespace ${namespace}`);
+	languageSet[userConfig.devLanguage] = devTranslation;
+	const devTranslationNoTags = withTags ? stripTagsFromTranslations(devTranslation) : devTranslation;
+	const altLanguages = getAltLanguages(userConfig);
+	for (const languageName of altLanguages) languageSet[languageName] = loadAltLanguageFile({
+		filePath,
+		languageName,
+		devTranslation: devTranslationNoTags,
+		fallbacks
+	}, userConfig);
+	for (const generatedLanguage of userConfig.generatedLanguages || []) {
+		const { name: generatedLanguageName, generator } = generatedLanguage;
+		const baseLanguage = generatedLanguage.extends || userConfig.devLanguage;
+		const baseTranslations = languageSet[baseLanguage];
+		languageSet[generatedLanguageName] = generateLanguageFromTranslations({
+			baseTranslations,
+			generator
+		});
+	}
+	return {
+		filePath,
+		keys: Object.keys(devTranslation),
+		namespace,
+		relativePath,
+		languages: languageSet,
+		metadata
+	};
+}
+async function loadAllTranslations({ fallbacks, includeNodeModules, withTags }, config) {
+	const { projectRoot, ignore = [] } = config;
+	const translationFiles = await (0, fast_glob.default)(getDevTranslationFileGlob(config), {
+		ignore: includeNodeModules ? ignore : [...ignore, "**/node_modules/**"],
+		absolute: true,
+		cwd: projectRoot
+	});
+	trace(`Found ${translationFiles.length} translation files`);
+	const loadedTranslations = [];
+	const keys = /* @__PURE__ */ new Set();
+	for (const translationFile of translationFiles) {
+		const loadedTranslation = loadTranslation({
+			filePath: translationFile,
+			fallbacks,
+			withTags
+		}, config);
+		loadedTranslations.push(loadedTranslation);
+		for (const key of loadedTranslation.keys) {
+			const uniqueKey = getUniqueKey(key, loadedTranslation.namespace);
+			if (keys.has(uniqueKey)) {
+				trace(`Duplicate keys found`);
+				throw new Error(`Duplicate keys found. Key with namespace ${loadedTranslation.namespace} and key ${key} was found multiple times.`);
+			}
+			keys.add(uniqueKey);
+			const globalKey = loadedTranslation.languages[config.devLanguage][key].globalKey;
+			if (globalKey) {
+				if (keys.has(globalKey)) throw new Error(`Duplicate keys found. Key with global key ${globalKey} and key ${key} was found multiple times`);
+				keys.add(globalKey);
+			}
+		}
+	}
+	return loadedTranslations;
+}
+
+//#endregion
+//#region src/compile.ts
+function extractHasTags(ast) {
+	return ast.some((element) => {
+		if ((0, __formatjs_icu_messageformat_parser.isSelectElement)(element) || (0, __formatjs_icu_messageformat_parser.isPluralElement)(element)) return Object.values(element.options).map((o) => o.value).some((child) => extractHasTags(child));
+		return (0, __formatjs_icu_messageformat_parser.isTagElement)(element);
+	});
+}
+function extractParamTypes(ast, currentParams) {
+	let params = { ...currentParams };
+	let vocabTypesImports = /* @__PURE__ */ new Set();
+	for (const element of ast) if ((0, __formatjs_icu_messageformat_parser.isArgumentElement)(element)) {
+		if (!(element.value in params)) params[element.value] = "string";
+	} else if ((0, __formatjs_icu_messageformat_parser.isNumberElement)(element)) params[element.value] = "number";
+	else if ((0, __formatjs_icu_messageformat_parser.isPluralElement)(element)) {
+		params[element.value] = "number";
+		const children = Object.values(element.options).map((o) => o.value);
+		for (const child of children) {
+			const [newParams, subImports] = extractParamTypes(child, params);
+			vocabTypesImports = new Set([...vocabTypesImports, ...subImports]);
+			params = newParams;
+		}
+	} else if ((0, __formatjs_icu_messageformat_parser.isDateElement)(element) || (0, __formatjs_icu_messageformat_parser.isTimeElement)(element)) params[element.value] = "Date | number";
+	else if ((0, __formatjs_icu_messageformat_parser.isTagElement)(element)) {
+		params[element.value] = "FormatXMLElementFn<T>";
+		vocabTypesImports.add("FormatXMLElementFn");
+		const [newParams, subImports] = extractParamTypes(element.children, params);
+		vocabTypesImports = new Set([...vocabTypesImports, ...subImports]);
+		params = newParams;
+	} else if ((0, __formatjs_icu_messageformat_parser.isSelectElement)(element)) {
+		const nonOtherOptionsUnion = Object.keys(element.options).filter((o) => o !== "other").map((o) => `'${o}'`).join(" | ");
+		params[element.value] = `StringWithSuggestions<${nonOtherOptionsUnion}>`;
+		vocabTypesImports.add("StringWithSuggestions");
+		const children = Object.values(element.options).map((o) => o.value);
+		for (const child of children) {
+			const [newParams, subImports] = extractParamTypes(child, params);
+			vocabTypesImports = new Set([...vocabTypesImports, ...subImports]);
+			params = newParams;
+		}
+	}
+	return [params, vocabTypesImports];
+}
+function serialiseObjectToType(v) {
+	let result = "";
+	for (const [key, value] of Object.entries(v)) result += `${JSON.stringify(key)}: ${value && typeof value === "object" ? serialiseObjectToType(value) : value},`;
+	return `{ ${result} }`;
+}
+const serializeTypeImports = (imports, moduleName) => {
+	if (imports.size === 0) return "";
+	return `import type { ${Array.from(imports).join(", ")} } from '${moduleName}';`;
+};
+function serialiseTranslationRuntime(value, imports, loadedTranslation) {
+	trace("Serialising translations:", loadedTranslation);
+	const translationsType = {};
+	for (const [key, { params, message, hasTags }] of value.entries()) {
+		let translationFunctionString = `() => ${message}`;
+		if (Object.keys(params).length > 0) {
+			const formatGeneric = hasTags ? "<T = string>" : "";
+			const formatReturn = hasTags && imports.has("FormatXMLElementFn") ? "ReturnType<FormatXMLElementFn<T>>" : "string";
+			translationFunctionString = `${formatGeneric}(values: ${serialiseObjectToType(params)}) => ${formatReturn}`;
+		}
+		translationsType[key] = translationFunctionString;
+	}
+	const languagesUnionAsString = Object.keys(loadedTranslation.languages).map((l) => `'${l}'`).join(" | ");
+	const languageEntries = Object.entries(loadedTranslation.languages).map(([languageName, translations]) => `${JSON.stringify(languageName)}: createLanguage(${JSON.stringify(getTranslationMessages(translations))})`).join(",");
+	return `
+    // This file is automatically generated by Vocab.
+    // To make changes update translation.json files directly.
+
+    ${serializeTypeImports(imports, "@vocab/core")}
+    import { createLanguage, createTranslationFile } from '@vocab/core/runtime';
+
+    const translations = createTranslationFile<
+      ${languagesUnionAsString},
+      ${serialiseObjectToType(translationsType)}
+    >({
+      ${languageEntries}
+    });
+
+    export default translations;
+  `;
+}
+async function generateRuntime(loadedTranslation) {
+	const { languages: loadedLanguages, filePath } = loadedTranslation;
+	trace("Generating types for", filePath);
+	const translationTypes = /* @__PURE__ */ new Map();
+	let imports = /* @__PURE__ */ new Set();
+	for (const key of loadedTranslation.keys) {
+		let params = {};
+		const messages = /* @__PURE__ */ new Set();
+		let hasTags = false;
+		for (const translatedLanguage of Object.values(loadedLanguages)) if (translatedLanguage[key]) {
+			const ast = (0, __formatjs_icu_messageformat_parser.parse)(translatedLanguage[key].message);
+			hasTags = hasTags || extractHasTags(ast);
+			const [parsedParams, vocabTypesImports] = extractParamTypes(ast, params);
+			imports = new Set([...imports, ...vocabTypesImports]);
+			params = parsedParams;
+			messages.add(JSON.stringify(translatedLanguage[key].message));
+		}
+		translationTypes.set(key, {
+			params,
+			hasTags,
+			message: Array.from(messages).join(" | ")
+		});
+	}
+	const prettierConfig = await prettier.default.resolveConfig(filePath);
+	const serializedTranslationType = serialiseTranslationRuntime(translationTypes, imports, loadedTranslation);
+	const declaration = await prettier.default.format(serializedTranslationType, {
+		...prettierConfig,
+		parser: "typescript"
+	});
+	const outputFilePath = getTSFileFromDevLanguageFile(filePath);
+	trace(`Writing translation types to ${outputFilePath}`);
+	await writeIfChanged(outputFilePath, declaration);
+}
+function watch(config) {
+	const cwd = config.projectRoot || process.cwd();
+	const watcher = chokidar.default.watch([
+		getDevTranslationFileGlob(config),
+		getAltTranslationFileGlob(config),
+		getTranslationFolderGlob(config)
+	], {
+		cwd,
+		ignored: config.ignore ? [...config.ignore, "**/node_modules/**"] : ["**/node_modules/**"],
+		ignoreInitial: true
+	});
+	const onTranslationChange = async (relativePath) => {
+		trace(`Detected change for file ${relativePath}`);
+		let targetFile;
+		if (isDevLanguageFile(relativePath)) targetFile = path.default.resolve(cwd, relativePath);
+		else if (isAltLanguageFile(relativePath)) targetFile = getDevLanguageFileFromAltLanguageFile(path.default.resolve(cwd, relativePath));
+		if (targetFile) try {
+			const loadedTranslation = loadTranslation({
+				filePath: targetFile,
+				fallbacks: "all"
+			}, config);
+			await generateRuntime(loadedTranslation);
+		} catch (e) {
+			console.log("Failed to generate types for", relativePath);
+			console.error(e);
+		}
+	};
+	const onNewDirectory = async (relativePath) => {
+		trace("Detected new directory", relativePath);
+		if (!isTranslationDirectory(relativePath, config)) {
+			trace("Ignoring non-translation directory:", relativePath);
+			return;
+		}
+		const newFilePath = path.default.join(relativePath, devTranslationFileName);
+		if (!(0, fs.existsSync)(newFilePath)) {
+			await fs.promises.writeFile(newFilePath, JSON.stringify({}, null, 2));
+			trace("Created new empty translation file:", newFilePath);
+		} else trace(`New directory already contains translation file. Skipping creation. Existing file ${newFilePath}`);
+	};
+	watcher.on("addDir", onNewDirectory);
+	watcher.on("add", onTranslationChange).on("change", onTranslationChange);
+	return () => watcher.close();
+}
+async function compile({ watch: shouldWatch = false } = {}, config) {
+	const translations = await loadAllTranslations({
+		fallbacks: "all",
+		includeNodeModules: false
+	}, config);
+	for (const loadedTranslation of translations) await generateRuntime(loadedTranslation);
+	if (shouldWatch) {
+		trace("Listening for changes to files...");
+		return watch(config);
+	}
+}
+async function writeIfChanged(filepath, contents) {
+	let hasChanged = true;
+	try {
+		hasChanged = await fs.promises.readFile(filepath, { encoding: "utf-8" }) !== contents;
+	} catch {}
+	if (hasChanged) await fs.promises.writeFile(filepath, contents, { encoding: "utf-8" });
+}
+
+//#endregion
+//#region src/validate/index.ts
+function findMissingKeys(loadedTranslation, devLanguageName, altLanguages) {
+	const devLanguage = loadedTranslation.languages[devLanguageName];
+	if (!devLanguage) throw new Error(`Failed to load dev language: ${loadedTranslation.filePath}`);
+	const result = {};
+	let valid = true;
+	const requiredKeys = Object.keys(devLanguage);
+	if (requiredKeys.length > 0) for (const altLanguageName of altLanguages) {
+		const altLanguage = loadedTranslation.languages[altLanguageName] ?? {};
+		for (const key of requiredKeys) if (typeof altLanguage[key]?.message !== "string") {
+			if (!result[altLanguageName]) result[altLanguageName] = [];
+			result[altLanguageName].push(key);
+			valid = false;
+		}
+	}
+	return [valid, result];
+}
+async function validate(config) {
+	const allTranslations = await loadAllTranslations({
+		fallbacks: "valid",
+		includeNodeModules: true
+	}, config);
+	let valid = true;
+	for (const loadedTranslation of allTranslations) {
+		const [translationValid, result] = findMissingKeys(loadedTranslation, config.devLanguage, getAltLanguages(config));
+		if (!translationValid) {
+			valid = false;
+			console.log(picocolors.default.red(`Incomplete translations: "${picocolors.default.bold(loadedTranslation.relativePath)}"`));
+			for (const lang of Object.keys(result)) {
+				const missingKeys = result[lang];
+				console.log(picocolors.default.yellow(lang), "->", missingKeys.map((v) => `"${v}"`).join(", "));
+			}
+		}
+	}
+	return valid;
+}
+
+//#endregion
+//#region src/ValidationError.ts
+var ValidationError = class extends Error {
+	code;
+	rawMessage;
+	constructor(code, message) {
+		super(`Invalid vocab.config.js: ${code} - ${message}`);
+		this.code = code;
+		this.rawMessage = message;
+	}
+};
+
+//#endregion
+//#region src/config.ts
+const boldCyan = (s) => picocolors.default.bold(picocolors.default.cyan(s));
+const checkConfigFile = new fastest_validator.default().compile({
+	$$strict: true,
+	devLanguage: { type: "string" },
+	languages: {
+		type: "array",
+		items: {
+			type: "object",
+			props: {
+				name: { type: "string" },
+				extends: {
+					type: "string",
+					optional: true
+				}
+			}
+		}
+	},
+	generatedLanguages: {
+		type: "array",
+		items: {
+			type: "object",
+			props: {
+				name: { type: "string" },
+				extends: {
+					type: "string",
+					optional: true
+				},
+				generator: {
+					type: "object",
+					props: {
+						transformElement: {
+							type: "function",
+							optional: true
+						},
+						transformMessage: {
+							type: "function",
+							optional: true
+						}
+					}
+				}
+			}
+		},
+		optional: true
+	},
+	translationsDirectorySuffix: {
+		type: "string",
+		optional: true
+	},
+	projectRoot: {
+		type: "string",
+		optional: true
+	},
+	ignore: {
+		type: "array",
+		items: "string",
+		optional: true
+	}
+});
+const splitMap = (message, callback) => message.split(" ,").map((v) => callback(v)).join(" ,");
+function validateConfig(c) {
+	trace("Validating configuration file");
+	const isValid = checkConfigFile(c);
+	if (isValid !== true) throw new ValidationError("InvalidStructure", (Array.isArray(isValid) ? isValid : []).map((v) => {
+		if (v.type === "objectStrict") return `Invalid key(s) ${splitMap(v.actual, (m) => `"${picocolors.default.cyan(m)}"`)}. Expected one of ${splitMap(v.expected, picocolors.default.green)}`;
+		if (v.field) return v.message?.replace(v.field, picocolors.default.cyan(v.field));
+		return v.message;
+	}).join(" \n"));
+	const languageStrings = c.languages.map((v) => v.name);
+	if (!languageStrings.includes(c.devLanguage)) throw new ValidationError("InvalidDevLanguage", `The dev language "${boldCyan(c.devLanguage)}" was not found in languages ${languageStrings.join(", ")}.`);
+	const foundLanguages = [];
+	for (const lang of c.languages) {
+		if (foundLanguages.includes(lang.name)) throw new ValidationError("DuplicateLanguage", `The language "${boldCyan(lang.name)}" was defined multiple times.`);
+		foundLanguages.push(lang.name);
+		if (lang.extends && !languageStrings.includes(lang.extends)) throw new ValidationError("InvalidExtends", `The language "${boldCyan(lang.name)}"'s extends of ${boldCyan(lang.extends)} was not found in languages ${languageStrings.join(", ")}.`);
+	}
+	const foundGeneratedLanguages = [];
+	for (const generatedLang of c.generatedLanguages || []) {
+		if (foundGeneratedLanguages.includes(generatedLang.name)) throw new ValidationError("DuplicateGeneratedLanguage", `The generated language "${boldCyan(generatedLang.name)}" was defined multiple times.`);
+		foundGeneratedLanguages.push(generatedLang.name);
+		if (languageStrings.includes(generatedLang.name)) throw new ValidationError("InvalidGeneratedLanguage", `The generated language "${boldCyan(generatedLang.name)}" is already defined as a language.`);
+		if (generatedLang.extends && !languageStrings.includes(generatedLang.extends)) throw new ValidationError("InvalidExtends", `The generated language "${boldCyan(generatedLang.name)}"'s extends of ${boldCyan(generatedLang.extends)} was not found in languages ${languageStrings.join(", ")}.`);
+	}
+	trace("Configuration file is valid");
+	return true;
+}
+function createConfig(configFilePath) {
+	return {
+		projectRoot: path.default.dirname(configFilePath),
+		...require(configFilePath)
+	};
+}
+async function resolveConfig(customConfigFilePath) {
+	const configFilePath = customConfigFilePath ? path.default.resolve(customConfigFilePath) : await (0, find_up.default)(["vocab.config.js", "vocab.config.cjs"]);
+	if (configFilePath) {
+		trace(`Resolved configuration file to ${configFilePath}`);
+		return createConfig(configFilePath);
+	}
+	trace("No configuration file found");
+	return null;
+}
+function resolveConfigSync(customConfigFilePath) {
+	const configFilePath = customConfigFilePath ? path.default.resolve(customConfigFilePath) : find_up.default.sync(["vocab.config.js", "vocab.config.cjs"]);
+	if (configFilePath) {
+		trace(`Resolved configuration file to ${configFilePath}`);
+		return createConfig(configFilePath);
+	}
+	trace("No configuration file found");
+	return null;
+}
+
+//#endregion
+exports.compile = compile;
+exports.getAltLanguageFilePath = getAltLanguageFilePath;
+exports.getAltLanguages = getAltLanguages;
+exports.getDevLanguageFileFromTsFile = getDevLanguageFileFromTsFile;
+exports.getUniqueKey = getUniqueKey;
+exports.loadAllTranslations = loadAllTranslations;
+exports.loadTranslation = loadTranslation;
+exports.resolveConfig = resolveConfig;
+exports.resolveConfigSync = resolveConfigSync;
+exports.validate = validate;
+exports.validateConfig = validateConfig;
+exports.watch = watch;
+//# sourceMappingURL=index.js.map