@vocab/core 1.6.3 → 1.6.5-fix-messageformat-import-20250923004826

package/dist/index.mjs

@@ -0,0 +1,660 @@
+import { createRequire } from "node:module";
+import IntlMessageFormat from "intl-messageformat";
+import { existsSync, promises } from "fs";
+import path from "path";
+import { TYPE, isArgumentElement, isDateElement, isNumberElement, isPluralElement, isSelectElement, isTagElement, isTimeElement, parse } from "@formatjs/icu-messageformat-parser";
+import prettier from "prettier";
+import chokidar from "chokidar";
+import pc from "picocolors";
+import debug from "debug";
+import glob from "fast-glob";
+import { printAST } from "@formatjs/icu-messageformat-parser/printer.js";
+import findUp from "find-up";
+import Validator from "fastest-validator";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/logger.ts
+const trace = debug(`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.dirname(tsFilePath);
+	const result = path.normalize(path.join(directory, devTranslationFileName));
+	trace(`Returning dev language path ${result} for path ${tsFilePath}`);
+	return result;
+}
+function getDevLanguageFileFromAltLanguageFile(altLanguageFilePath) {
+	const directory = path.dirname(altLanguageFilePath);
+	const result = path.normalize(path.join(directory, devTranslationFileName));
+	trace(`Returning dev language path ${result} for path ${altLanguageFilePath}`);
+	return result;
+}
+function getTSFileFromDevLanguageFile(devLanguageFilePath) {
+	const directory = path.dirname(devLanguageFilePath);
+	const result = path.normalize(path.join(directory, "index.ts"));
+	trace(`Returning TS path ${result} for path ${devLanguageFilePath}`);
+	return result;
+}
+function getAltLanguageFilePath(devLanguageFilePath, language) {
+	const directory = path.dirname(devLanguageFilePath);
+	const result = path.normalize(path.join(directory, `${language}.translations.json`));
+	trace(`Returning alt language path ${result} for path ${devLanguageFilePath}`);
+	return path.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 IntlMessageFormat(translation.message).getAst().map(transformMessageFormatElement(generator.transformElement));
+			transformedMessage = 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 TYPE.literal:
+				transformedMessageFormatElement.value = transformElement(transformedMessageFormatElement.value);
+				break;
+			case TYPE.select:
+			case TYPE.plural:
+				const transformedOptions = { ...transformedMessageFormatElement.options };
+				for (const key of Object.keys(transformedOptions)) transformedOptions[key].value = transformedOptions[key].value.map(transformMessageFormatElement(transformElement));
+				break;
+			case 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.dirname(relativePath).replace(/^src\//, "").replace(/\//g, "_");
+	if (namespace.endsWith(translationsDirectorySuffix)) namespace = namespace.slice(0, -translationsDirectorySuffix.length);
+	return namespace;
+}
+function printValidationError(...params) {
+	console.error(pc.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.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 glob(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 (isSelectElement(element) || isPluralElement(element)) return Object.values(element.options).map((o) => o.value).some((child) => extractHasTags(child));
+		return isTagElement(element);
+	});
+}
+function extractParamTypes(ast, currentParams) {
+	let params = { ...currentParams };
+	let vocabTypesImports = /* @__PURE__ */ new Set();
+	for (const element of ast) if (isArgumentElement(element)) {
+		if (!(element.value in params)) params[element.value] = "string";
+	} else if (isNumberElement(element)) params[element.value] = "number";
+	else if (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 (isDateElement(element) || isTimeElement(element)) params[element.value] = "Date | number";
+	else if (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 (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 = 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.resolveConfig(filePath);
+	const serializedTranslationType = serialiseTranslationRuntime(translationTypes, imports, loadedTranslation);
+	const declaration = await prettier.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.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.resolve(cwd, relativePath);
+		else if (isAltLanguageFile(relativePath)) targetFile = getDevLanguageFileFromAltLanguageFile(path.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.join(relativePath, devTranslationFileName);
+		if (!existsSync(newFilePath)) {
+			await 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 promises.readFile(filepath, { encoding: "utf-8" }) !== contents;
+	} catch {}
+	if (hasChanged) await 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(pc.red(`Incomplete translations: "${pc.bold(loadedTranslation.relativePath)}"`));
+			for (const lang of Object.keys(result)) {
+				const missingKeys = result[lang];
+				console.log(pc.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) => pc.bold(pc.cyan(s));
+const checkConfigFile = new Validator().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) => `"${pc.cyan(m)}"`)}. Expected one of ${splitMap(v.expected, pc.green)}`;
+		if (v.field) return v.message?.replace(v.field, pc.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.dirname(configFilePath),
+		...__require(configFilePath)
+	};
+}
+async function resolveConfig(customConfigFilePath) {
+	const configFilePath = customConfigFilePath ? path.resolve(customConfigFilePath) : await findUp(["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.resolve(customConfigFilePath) : findUp.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
+export { compile, getAltLanguageFilePath, getAltLanguages, getDevLanguageFileFromTsFile, getUniqueKey, loadAllTranslations, loadTranslation, resolveConfig, resolveConfigSync, validate, validateConfig, watch };
+//# sourceMappingURL=index.mjs.map