@intlayer/chokidar/dist/esm/buildIntlayerDictionary/writeDynamicDictionary.mjs

Uses chokidar to scan and build Intlayer declaration files into dictionaries based on Intlayer configuration.

import { parallelize } from "../utils/parallelize.mjs";
import { writeFileIfChanged } from "../writeFileIfChanged.mjs";
import { writeJsonIfChanged } from "../writeJsonIfChanged.mjs";
import { mkdir } from "node:fs/promises";
import { resolve } from "node:path";
import { colorizePath } from "@intlayer/config/logger";
import { assertPathWithin } from "@intlayer/config/utils";
import { OUTPUT_FORMAT } from "@intlayer/config/defaultValues";
import { getPerLocaleDictionary } from "@intlayer/core/plugins";

//#region src/buildIntlayerDictionary/writeDynamicDictionary.ts
const DICTIONARIES_SUBDIR = "json";
/**
* Generates the content of a dictionary entry point file.
*/
const generateDictionaryEntryPoint = (key, locales, format = "esm") => {
	const localeEntries = [...locales].sort((a, b) => String(a).localeCompare(String(b))).map((locale) => format === "esm" ? `  '${locale}': () => import('./${DICTIONARIES_SUBDIR}/${key}/${locale}.json').then(m => m.default)` : `  '${locale}': () => Promise.resolve(require('./${DICTIONARIES_SUBDIR}/${key}/${locale}.json'))`).join(",\n");
	if (format === "esm") return `const content = {\n${localeEntries}\n};\n\nexport default content;\n`;
	return `module.exports = {\n${localeEntries}\n};\n`;
};
/**
* Write the localized dictionaries to the dictionariesDir
* @param mergedDictionaries - The merged dictionaries
* @param configuration - The configuration
* @returns The final dictionaries
*
* @example
* ```ts
* const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);
* const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);
* console.log(finalDictionaries);
*
* // .intlayer/dynamic_dictionary/dictionaries/en_home.json
* // .intlayer/dynamic_dictionary/dictionaries/fr_home.json
* ```
*/
const writeDynamicDictionary = async (mergedDictionaries, configuration, formats = OUTPUT_FORMAT) => {
	const { locales, defaultLocale } = configuration.internationalization;
	const { dynamicDictionariesDir } = configuration.system;
	const dictDir = resolve(dynamicDictionariesDir, DICTIONARIES_SUBDIR);
	await mkdir(dictDir, { recursive: true });
	const resultDictionariesPaths = {};
	await parallelize(Object.entries(mergedDictionaries).sort(([a], [b]) => String(a).localeCompare(String(b))), async ([key, dictionaryEntry]) => {
		if (key === "undefined") return;
		const localizedDictionariesPathsRecord = {};
		const keyDir = resolve(dictDir, key);
		assertPathWithin(keyDir, dictDir);
		await mkdir(keyDir, { recursive: true });
		await parallelize(locales, async (locale) => {
			const localizedDictionary = getPerLocaleDictionary(dictionaryEntry.dictionary, locale, defaultLocale);
			const resultFilePath = resolve(keyDir, `${locale}.json`);
			await writeJsonIfChanged(resultFilePath, localizedDictionary).catch((err) => {
				console.error(`Error creating localized ${key}/${locale}.json:`, err);
			});
			localizedDictionariesPathsRecord[locale] = {
				dictionaryPath: resultFilePath,
				dictionary: localizedDictionary
			};
		});
		resultDictionariesPaths[key] = localizedDictionariesPathsRecord;
		await parallelize(formats, async (format) => {
			const extension = format === "cjs" ? "cjs" : "mjs";
			const content = generateDictionaryEntryPoint(key, locales, format);
			const dynEntryPath = resolve(dynamicDictionariesDir, `${key}.${extension}`);
			assertPathWithin(dynEntryPath, dynamicDictionariesDir);
			await writeFileIfChanged(dynEntryPath, content).catch((err) => {
				console.error(`Error creating dynamic ${colorizePath(dynEntryPath)}:`, err);
			});
		});
	});
	return resultDictionariesPaths;
};

//#endregion
export { generateDictionaryEntryPoint, writeDynamicDictionary };
//# sourceMappingURL=writeDynamicDictionary.mjs.map