@intlayer/engine 9.0.0-canary.12

package/dist/cjs/buildIntlayerDictionary/writeRemoteDictionary.cjs

@@ -0,0 +1,51 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_utils_parallelize = require('../utils/parallelize.cjs');
+const require_writeJsonIfChanged = require('../writeJsonIfChanged.cjs');
+const require_filterInvalidDictionaries = require('../filterInvalidDictionaries.cjs');
+const require_buildIntlayerDictionary_writeUnmergedDictionary = require('./writeUnmergedDictionary.cjs');
+const require_loadDictionaries_loadRemoteDictionaries = require('../loadDictionaries/loadRemoteDictionaries.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let _intlayer_config_logger = require("@intlayer/config/logger");
+let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryManipulator");
+
+//#region src/buildIntlayerDictionary/writeRemoteDictionary.ts
+/**
+* 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/fetch_dictionaries/home.json
+* // { key: 'home', content: { ... } },
+* ```
+*/
+const writeRemoteDictionary = async (remoteDictionaries, configuration) => {
+	const { remoteDictionariesDir } = configuration.system;
+	await (0, node_fs_promises.mkdir)((0, node_path.resolve)(remoteDictionariesDir), { recursive: true });
+	const groupedDictionaries = require_buildIntlayerDictionary_writeUnmergedDictionary.groupDictionariesByKey(require_filterInvalidDictionaries.filterInvalidDictionaries(remoteDictionaries, configuration));
+	const results = await require_utils_parallelize.parallelize(Object.entries(groupedDictionaries), async ([key, dictionaries]) => {
+		if (key === "undefined") return;
+		const orderedDictionaries = (0, _intlayer_core_dictionaryManipulator.orderDictionaries)(require_loadDictionaries_loadRemoteDictionaries.formatDistantDictionaries(dictionaries));
+		const unmergedFilePath = (0, node_path.resolve)(remoteDictionariesDir, `${key}.json`);
+		await require_writeJsonIfChanged.writeJsonIfChanged(unmergedFilePath, orderedDictionaries).catch((err) => {
+			console.error(`${_intlayer_config_logger.x} Error creating unmerged ${(0, _intlayer_config_logger.colorizePath)(unmergedFilePath)}:`, err);
+		});
+		return [key, {
+			dictionaryPath: unmergedFilePath,
+			dictionaries
+		}];
+	});
+	return Object.fromEntries(results.filter(Boolean));
+};
+
+//#endregion
+exports.writeRemoteDictionary = writeRemoteDictionary;
+//# sourceMappingURL=writeRemoteDictionary.cjs.map

package/dist/cjs/buildIntlayerDictionary/writeRemoteDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeRemoteDictionary.cjs","names":["groupDictionariesByKey","filterInvalidDictionaries","parallelize","formatDistantDictionaries","writeJsonIfChanged","x"],"sources":["../../../src/buildIntlayerDictionary/writeRemoteDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { colorizePath, x } from '@intlayer/config/logger';\nimport { orderDictionaries } from '@intlayer/core/dictionaryManipulator';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { filterInvalidDictionaries } from '../filterInvalidDictionaries';\nimport { formatDistantDictionaries } from '../loadDictionaries';\nimport { parallelize } from '../utils/parallelize';\nimport { writeJsonIfChanged } from '../writeJsonIfChanged';\nimport {\n  groupDictionariesByKey,\n  type UnmergedDictionaryResult,\n} from './writeUnmergedDictionary';\n\nexport type RemoteDictionaryResult = {\n  dictionaryPath: string;\n  dictionaries: Dictionary[];\n};\n\nexport type RemoteDictionaryOutput = Record<string, RemoteDictionaryResult>;\n\n/**\n * Write the localized dictionaries to the dictionariesDir\n * @param mergedDictionaries - The merged dictionaries\n * @param configuration - The configuration\n * @returns The final dictionaries\n *\n * @example\n * ```ts\n * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);\n * const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);\n * console.log(finalDictionaries);\n *\n * // .intlayer/fetch_dictionaries/home.json\n * // { key: 'home', content: { ... } },\n * ```\n */\nexport const writeRemoteDictionary = async (\n  remoteDictionaries: Dictionary[],\n  configuration: IntlayerConfig\n): Promise<RemoteDictionaryOutput> => {\n  const { remoteDictionariesDir } = configuration.system;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(remoteDictionariesDir), { recursive: true });\n\n  const filteredDictionaries = filterInvalidDictionaries(\n    remoteDictionaries,\n    configuration\n  );\n\n  //  Group dictionaries by key and write to unmergedDictionariesDir\n  const groupedDictionaries = groupDictionariesByKey(filteredDictionaries);\n\n  // Merge dictionaries with the same key and write to dictionariesDir\n  const results = await parallelize(\n    Object.entries(groupedDictionaries),\n    async ([key, dictionaries]) => {\n      if (key === 'undefined') {\n        return undefined as unknown as readonly [\n          string,\n          UnmergedDictionaryResult,\n        ];\n      }\n\n      const formattedDictionaries = formatDistantDictionaries(dictionaries);\n\n      const orderedDictionaries = orderDictionaries(formattedDictionaries);\n\n      const outputFileName = `${key}.json`;\n      const unmergedFilePath = resolve(remoteDictionariesDir, outputFileName);\n\n      // Write the grouped dictionaries\n      await writeJsonIfChanged(unmergedFilePath, orderedDictionaries).catch(\n        (err) => {\n          console.error(\n            `${x} Error creating unmerged ${colorizePath(unmergedFilePath)}:`,\n            err\n          );\n        }\n      );\n\n      return [\n        key,\n        {\n          dictionaryPath: unmergedFilePath,\n          dictionaries,\n        } as UnmergedDictionaryResult,\n      ] as const;\n    }\n  );\n\n  return Object.fromEntries(\n    results.filter(Boolean) as Array<\n      readonly [string, UnmergedDictionaryResult]\n    >\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,MAAa,wBAAwB,OACnC,oBACA,kBACoC;CACpC,MAAM,EAAE,0BAA0B,cAAc;AAGhD,0DAAoB,sBAAsB,EAAE,EAAE,WAAW,MAAM,CAAC;CAQhE,MAAM,sBAAsBA,+EANCC,4DAC3B,oBACA,cAIqE,CAAC;CAGxE,MAAM,UAAU,MAAMC,sCACpB,OAAO,QAAQ,oBAAoB,EACnC,OAAO,CAAC,KAAK,kBAAkB;AAC7B,MAAI,QAAQ,YACV;EAQF,MAAM,kFAFwBC,0EAA0B,aAEW,CAAC;EAGpE,MAAM,0CAA2B,uBAAuB,GAD9B,IAAI,OACyC;AAGvE,QAAMC,8CAAmB,kBAAkB,oBAAoB,CAAC,OAC7D,QAAQ;AACP,WAAQ,MACN,GAAGC,0BAAE,qEAAwC,iBAAiB,CAAC,IAC/D,IACD;IAEJ;AAED,SAAO,CACL,KACA;GACE,gBAAgB;GAChB;GACD,CACF;GAEJ;AAED,QAAO,OAAO,YACZ,QAAQ,OAAO,QAAQ,CAGxB"}

package/dist/cjs/buildIntlayerDictionary/writeUnmergedDictionary.cjs

@@ -0,0 +1,62 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_utils_parallelize = require('../utils/parallelize.cjs');
+const require_writeJsonIfChanged = require('../writeJsonIfChanged.cjs');
+const require_filterInvalidDictionaries = require('../filterInvalidDictionaries.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let _intlayer_config_logger = require("@intlayer/config/logger");
+let _intlayer_config_utils = require("@intlayer/config/utils");
+let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryManipulator");
+
+//#region src/buildIntlayerDictionary/writeUnmergedDictionary.ts
+const groupDictionariesByKey = (dictionaries) => dictionaries.reduce((acc, dictionary) => {
+	const key = dictionary.key;
+	if (!acc[key]) acc[key] = [];
+	acc[key].push(dictionary);
+	return acc;
+}, {});
+/**
+* Write the unmerged dictionaries to the unmergedDictionariesDir
+* @param dictionaries - The dictionaries to write
+* @param configuration - The configuration
+* @returns The grouped dictionaries
+*
+* @example
+* ```ts
+* const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);
+* console.log(unmergedDictionaries);
+*
+* // .intlayer/unmerged_dictionaries/home.json
+* // {
+* //   [
+* //     { key: 'home', content: { ... } },
+* //     { key: 'home', content: { ... } },
+* //   ],
+* // }
+* ```
+*/
+const writeUnmergedDictionaries = async (dictionaries, configuration, env) => {
+	const { unmergedDictionariesDir } = configuration.system;
+	await (0, node_fs_promises.mkdir)((0, node_path.resolve)(unmergedDictionariesDir), { recursive: true });
+	const groupedDictionaries = groupDictionariesByKey(require_filterInvalidDictionaries.filterInvalidDictionaries(dictionaries, configuration, { checkSchema: true }));
+	const results = await require_utils_parallelize.parallelize(Object.entries(groupedDictionaries), async ([key, dictionaries]) => {
+		if (key === "undefined") return;
+		const orderedDictionaries = (0, _intlayer_core_dictionaryManipulator.orderDictionaries)(dictionaries);
+		const unmergedFilePath = (0, node_path.resolve)(unmergedDictionariesDir, `${key}.json`);
+		(0, _intlayer_config_utils.assertPathWithin)(unmergedFilePath, unmergedDictionariesDir);
+		if (configuration.editor.enabled || env === "dev") await require_writeJsonIfChanged.writeJsonIfChanged(unmergedFilePath, orderedDictionaries).catch((err) => {
+			console.error(`${_intlayer_config_logger.x} Error creating unmerged ${(0, _intlayer_config_logger.colorizePath)(unmergedFilePath)}:`, err);
+		});
+		return [key, {
+			dictionaryPath: unmergedFilePath,
+			dictionaries
+		}];
+	});
+	return Object.fromEntries(results.filter(Boolean));
+};
+
+//#endregion
+exports.groupDictionariesByKey = groupDictionariesByKey;
+exports.writeUnmergedDictionaries = writeUnmergedDictionaries;
+//# sourceMappingURL=writeUnmergedDictionary.cjs.map

package/dist/cjs/buildIntlayerDictionary/writeUnmergedDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeUnmergedDictionary.cjs","names":["filterInvalidDictionaries","parallelize","writeJsonIfChanged","x"],"sources":["../../../src/buildIntlayerDictionary/writeUnmergedDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { colorizePath, x } from '@intlayer/config/logger';\nimport { assertPathWithin } from '@intlayer/config/utils';\nimport { orderDictionaries } from '@intlayer/core/dictionaryManipulator';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary, DictionaryKey } from '@intlayer/types/dictionary';\nimport { filterInvalidDictionaries } from '../filterInvalidDictionaries';\nimport { parallelize } from '../utils/parallelize';\nimport { writeJsonIfChanged } from '../writeJsonIfChanged';\n\nexport const groupDictionariesByKey = (\n  dictionaries: Dictionary[]\n): Record<string, Dictionary[]> =>\n  dictionaries.reduce(\n    (acc, dictionary) => {\n      const key = dictionary.key;\n      if (!acc[key]) {\n        acc[key] = [];\n      }\n      acc[key].push(dictionary);\n      return acc;\n    },\n    {} as Record<string, Dictionary[]>\n  );\n\nexport type UnmergedDictionaryResult = {\n  dictionaryPath: string;\n  dictionaries: Dictionary[];\n};\n\nexport type UnmergedDictionaryOutput = Record<\n  DictionaryKey,\n  UnmergedDictionaryResult\n>;\n\n/**\n * Write the unmerged dictionaries to the unmergedDictionariesDir\n * @param dictionaries - The dictionaries to write\n * @param configuration - The configuration\n * @returns The grouped dictionaries\n *\n * @example\n * ```ts\n * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);\n * console.log(unmergedDictionaries);\n *\n * // .intlayer/unmerged_dictionaries/home.json\n * // {\n * //   [\n * //     { key: 'home', content: { ... } },\n * //     { key: 'home', content: { ... } },\n * //   ],\n * // }\n * ```\n */\nexport const writeUnmergedDictionaries = async (\n  dictionaries: Dictionary[],\n  configuration: IntlayerConfig,\n  env: 'prod' | 'dev'\n): Promise<UnmergedDictionaryOutput> => {\n  const { unmergedDictionariesDir } = configuration.system;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(unmergedDictionariesDir), { recursive: true });\n\n  const filteredDictionaries = filterInvalidDictionaries(\n    dictionaries,\n    configuration,\n    { checkSchema: true }\n  );\n\n  //  Group dictionaries by key and write to unmergedDictionariesDir\n  const groupedDictionaries = groupDictionariesByKey(filteredDictionaries);\n\n  const results = await parallelize(\n    Object.entries(groupedDictionaries),\n    async ([key, dictionaries]) => {\n      if (key === 'undefined') {\n        return undefined as unknown as readonly [\n          string,\n          UnmergedDictionaryResult,\n        ];\n      }\n\n      const orderedDictionaries = orderDictionaries(dictionaries);\n\n      const outputFileName = `${key}.json`;\n      const unmergedFilePath = resolve(unmergedDictionariesDir, outputFileName);\n\n      assertPathWithin(unmergedFilePath, unmergedDictionariesDir);\n\n      // Write the grouped dictionaries in disk if the editor is enabled\n      // To make work the visual editor on the server\n      // No need them if the editor is disabled\n      // But in local env (env: 'dev') we write them for the vscode extension\n      if (configuration.editor.enabled || env === 'dev') {\n        await writeJsonIfChanged(unmergedFilePath, orderedDictionaries).catch(\n          (err) => {\n            console.error(\n              `${x} Error creating unmerged ${colorizePath(unmergedFilePath)}:`,\n              err\n            );\n          }\n        );\n      }\n\n      return [\n        key,\n        {\n          dictionaryPath: unmergedFilePath,\n          dictionaries: dictionaries,\n        } as UnmergedDictionaryResult,\n      ] as const;\n    }\n  );\n\n  return Object.fromEntries(\n    results.filter(Boolean) as Array<\n      readonly [string, UnmergedDictionaryResult]\n    >\n  );\n};\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,0BACX,iBAEA,aAAa,QACV,KAAK,eAAe;CACnB,MAAM,MAAM,WAAW;AACvB,KAAI,CAAC,IAAI,KACP,KAAI,OAAO,EAAE;AAEf,KAAI,KAAK,KAAK,WAAW;AACzB,QAAO;GAET,EAAE,CACH;;;;;;;;;;;;;;;;;;;;;AAgCH,MAAa,4BAA4B,OACvC,cACA,eACA,QACsC;CACtC,MAAM,EAAE,4BAA4B,cAAc;AAGlD,0DAAoB,wBAAwB,EAAE,EAAE,WAAW,MAAM,CAAC;CASlE,MAAM,sBAAsB,uBAPCA,4DAC3B,cACA,eACA,EAAE,aAAa,MAAM,CAIgD,CAAC;CAExE,MAAM,UAAU,MAAMC,sCACpB,OAAO,QAAQ,oBAAoB,EACnC,OAAO,CAAC,KAAK,kBAAkB;AAC7B,MAAI,QAAQ,YACV;EAMF,MAAM,kFAAwC,aAAa;EAG3D,MAAM,0CAA2B,yBAAyB,GADhC,IAAI,OAC2C;AAEzE,+CAAiB,kBAAkB,wBAAwB;AAM3D,MAAI,cAAc,OAAO,WAAW,QAAQ,MAC1C,OAAMC,8CAAmB,kBAAkB,oBAAoB,CAAC,OAC7D,QAAQ;AACP,WAAQ,MACN,GAAGC,0BAAE,qEAAwC,iBAAiB,CAAC,IAC/D,IACD;IAEJ;AAGH,SAAO,CACL,KACA;GACE,gBAAgB;GACF;GACf,CACF;GAEJ;AAED,QAAO,OAAO,YACZ,QAAQ,OAAO,QAAQ,CAGxB"}

package/dist/cjs/cleanOutputDir.cjs

@@ -0,0 +1,31 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+let node_fs_promises = require("node:fs/promises");
+let _intlayer_config_logger = require("@intlayer/config/logger");
+let node_fs = require("node:fs");
+
+//#region src/cleanOutputDir.ts
+const cleanOutputDir = async (configuration) => {
+	const { dictionariesDir, unmergedDictionariesDir, dynamicDictionariesDir, remoteDictionariesDir, fetchDictionariesDir, mainDir, typesDir, configDir, cacheDir } = configuration.system;
+	const appLogger = (0, _intlayer_config_logger.getAppLogger)(configuration);
+	const directoriesToClean = [
+		dictionariesDir,
+		unmergedDictionariesDir,
+		dynamicDictionariesDir,
+		remoteDictionariesDir,
+		fetchDictionariesDir,
+		mainDir,
+		typesDir,
+		configDir,
+		cacheDir
+	];
+	await Promise.all(directoriesToClean.filter((dir) => (0, node_fs.existsSync)(dir)).map((dir) => (0, node_fs_promises.rm)(dir, {
+		recursive: true,
+		force: true
+	})));
+	appLogger("Output directory cleaned", { isVerbose: true });
+};
+
+//#endregion
+exports.cleanOutputDir = cleanOutputDir;
+//# sourceMappingURL=cleanOutputDir.cjs.map

package/dist/cjs/cleanOutputDir.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanOutputDir.cjs","names":[],"sources":["../../src/cleanOutputDir.ts"],"sourcesContent":["import { existsSync } from 'node:fs';\nimport { rm } from 'node:fs/promises';\nimport { getAppLogger } from '@intlayer/config/logger';\nimport type { IntlayerConfig } from '@intlayer/types/config';\n\nexport const cleanOutputDir = async (configuration: IntlayerConfig) => {\n  const {\n    dictionariesDir,\n    unmergedDictionariesDir,\n    dynamicDictionariesDir,\n    remoteDictionariesDir,\n    fetchDictionariesDir,\n    mainDir,\n    typesDir,\n    configDir,\n    cacheDir,\n  } = configuration.system;\n\n  const appLogger = getAppLogger(configuration);\n\n  const directoriesToClean: string[] = [\n    dictionariesDir, // Merged dictionaries\n    unmergedDictionariesDir, // Unmerged dictionaries\n    dynamicDictionariesDir, // Dynamic dictionaries\n    remoteDictionariesDir, // Remote dictionaries\n    fetchDictionariesDir, // Fetch dictionaries\n    mainDir, // Main files\n    typesDir, // Types\n    configDir, // Configuration\n    cacheDir, // Cache\n  ];\n\n  // Execute all deletions in parallel\n  await Promise.all(\n    directoriesToClean\n      .filter((dir) => existsSync(dir))\n      .map((dir) => rm(dir, { recursive: true, force: true }))\n  );\n\n  appLogger('Output directory cleaned', {\n    isVerbose: true,\n  });\n};\n"],"mappings":";;;;;;;AAKA,MAAa,iBAAiB,OAAO,kBAAkC;CACrE,MAAM,EACJ,iBACA,yBACA,wBACA,uBACA,sBACA,SACA,UACA,WACA,aACE,cAAc;CAElB,MAAM,sDAAyB,cAAc;CAE7C,MAAM,qBAA+B;EACnC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD;AAGD,OAAM,QAAQ,IACZ,mBACG,QAAQ,gCAAmB,IAAI,CAAC,CAChC,KAAK,iCAAW,KAAK;EAAE,WAAW;EAAM,OAAO;EAAM,CAAC,CAAC,CAC3D;AAED,WAAU,4BAA4B,EACpC,WAAW,MACZ,CAAC"}

package/dist/cjs/cleanRemovedContentDeclaration.cjs

@@ -0,0 +1,97 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+const require_createDictionaryEntryPoint_createDictionaryEntryPoint = require('./createDictionaryEntryPoint/createDictionaryEntryPoint.cjs');
+const require_utils_readDictionariesFromDisk = require('./utils/readDictionariesFromDisk.cjs');
+const require_writeJsonIfChanged = require('./writeJsonIfChanged.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let _intlayer_config_client = require("@intlayer/config/client");
+let _intlayer_config_logger = require("@intlayer/config/logger");
+let fast_glob = require("fast-glob");
+fast_glob = require_runtime.__toESM(fast_glob);
+
+//#region src/cleanRemovedContentDeclaration.ts
+const cleanRemovedContentDeclaration = async (filePath, keysToKeep, configuration) => {
+	const appLogger = (0, _intlayer_config_logger.getAppLogger)(configuration);
+	const unmergedDictionaries = require_utils_readDictionariesFromDisk.readDictionariesFromDisk(configuration.system.unmergedDictionariesDir);
+	const baseDir = configuration.system.baseDir;
+	const relativeFilePath = (0, node_path.relative)(baseDir, filePath);
+	const uniqueUnmergedDictionaries = Object.values(unmergedDictionaries).flat().filter((dictionary) => dictionary.filePath === relativeFilePath && !keysToKeep.includes(dictionary.key)).filter((dictionary, index, self) => index === self.findIndex((t) => t.key === dictionary.key));
+	const changedDictionariesLocalIds = [];
+	const filesToRemove = [];
+	const excludeKeys = [];
+	await Promise.all(uniqueUnmergedDictionaries.map(async (dictionary) => {
+		const unmergedFilePath = (0, node_path.normalize)((0, node_path.join)(configuration.system.unmergedDictionariesDir, `${dictionary.key}.json`));
+		try {
+			const jsonContent = await (0, node_fs_promises.readFile)(unmergedFilePath, "utf8");
+			const parsedContent = JSON.parse(jsonContent);
+			if (parsedContent.length === 1) {
+				if (parsedContent[0].filePath === relativeFilePath) {
+					appLogger(`Removing outdated dictionary ${(0, _intlayer_config_logger.colorizeKey)(dictionary.key)}`, { isVerbose: true });
+					filesToRemove.push(unmergedFilePath);
+					excludeKeys.push(dictionary.key);
+				}
+			} else {
+				await require_writeJsonIfChanged.writeJsonIfChanged(unmergedFilePath, parsedContent.filter((content) => content.filePath !== relativeFilePath));
+				changedDictionariesLocalIds.push(dictionary.localId);
+			}
+		} catch (error) {
+			if (error.code === "ENOENT") {
+				if (!excludeKeys.includes(dictionary.key)) excludeKeys.push(dictionary.key);
+			}
+		}
+	}));
+	const dictionaries = require_utils_readDictionariesFromDisk.readDictionariesFromDisk(configuration.system.dictionariesDir);
+	const uniqueMergedDictionaries = (Object.values(dictionaries)?.filter((dictionary) => !keysToKeep.includes(dictionary.key) && dictionary.localIds?.length === 1 && dictionary.localIds[0].endsWith(`::local::${relativeFilePath}`))).filter((dictionary, index, self) => index === self.findIndex((t) => t.key === dictionary.key));
+	await Promise.all(uniqueMergedDictionaries.map(async (dictionary) => {
+		const mergedFilePath = (0, node_path.normalize)((0, node_path.join)(configuration.system.dictionariesDir, `${dictionary.key}.json`));
+		try {
+			const fileContent = await (0, node_fs_promises.readFile)(mergedFilePath, "utf8");
+			const parsedContent = JSON.parse(fileContent);
+			if (parsedContent.localIds?.length === 1) {
+				if (parsedContent.localIds[0].endsWith(`::local::${relativeFilePath}`)) {
+					appLogger(`Removing outdated unmerged dictionary ${(0, _intlayer_config_logger.colorizeKey)(dictionary.key)}`, { isVerbose: true });
+					filesToRemove.push(mergedFilePath);
+					const typesFilePath = (0, node_path.normalize)((0, node_path.join)(configuration.system.typesDir, `${dictionary.key}.ts`));
+					filesToRemove.push(typesFilePath);
+					const dynamicFiles = await (0, fast_glob.default)((0, _intlayer_config_client.normalizePath)((0, node_path.join)(configuration.system.dynamicDictionariesDir, `${dictionary.key}.*`)), { absolute: true });
+					filesToRemove.push(...dynamicFiles);
+					if (!excludeKeys.includes(dictionary.key)) excludeKeys.push(dictionary.key);
+				}
+			} else {
+				const localIds = parsedContent.localIds?.filter((localeId) => !localeId.endsWith(`::local::${relativeFilePath}`));
+				await require_writeJsonIfChanged.writeJsonIfChanged(mergedFilePath, {
+					...parsedContent,
+					localIds
+				});
+			}
+		} catch (error) {
+			if (error.code === "ENOENT") {
+				if (!excludeKeys.includes(dictionary.key)) excludeKeys.push(dictionary.key);
+				const typesFilePath = (0, node_path.normalize)((0, node_path.join)(configuration.system.typesDir, `${dictionary.key}.ts`));
+				filesToRemove.push(typesFilePath);
+			}
+		}
+	}));
+	if (filesToRemove.length > 0 || excludeKeys.length > 0) {
+		await require_createDictionaryEntryPoint_createDictionaryEntryPoint.createDictionaryEntryPoint(configuration, { excludeKeys });
+		if (filesToRemove.length > 0) setTimeout(async () => await Promise.all(filesToRemove.map(async (path) => {
+			const relativePath = (0, node_path.relative)(baseDir, path);
+			try {
+				await (0, node_fs_promises.rm)(path, { force: true });
+				appLogger(`Deleted artifact: ${(0, _intlayer_config_logger.colorizePath)(relativePath)}`, { isVerbose: true });
+			} catch {
+				appLogger(`Error while removing file ${(0, _intlayer_config_logger.colorizePath)(relativePath)}`, { isVerbose: true });
+			}
+		})), 3e3);
+	}
+	return {
+		changedDictionariesLocalIds,
+		excludeKeys,
+		hasRebuilt: filesToRemove.length > 0 || excludeKeys.length > 0
+	};
+};
+
+//#endregion
+exports.cleanRemovedContentDeclaration = cleanRemovedContentDeclaration;
+//# sourceMappingURL=cleanRemovedContentDeclaration.cjs.map

package/dist/cjs/cleanRemovedContentDeclaration.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanRemovedContentDeclaration.cjs","names":["readDictionariesFromDisk","writeJsonIfChanged","createDictionaryEntryPoint"],"sources":["../../src/cleanRemovedContentDeclaration.ts"],"sourcesContent":["import { readFile, rm } from 'node:fs/promises';\nimport { join, normalize, relative } from 'node:path';\nimport { normalizePath } from '@intlayer/config/client';\nimport {\n  colorizeKey,\n  colorizePath,\n  getAppLogger,\n} from '@intlayer/config/logger';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport fg from 'fast-glob';\nimport { createDictionaryEntryPoint } from './createDictionaryEntryPoint';\nimport { readDictionariesFromDisk } from './utils/readDictionariesFromDisk';\nimport { writeJsonIfChanged } from './writeJsonIfChanged';\n\nexport const cleanRemovedContentDeclaration = async (\n  filePath: string,\n  keysToKeep: string[],\n  configuration: IntlayerConfig\n): Promise<{\n  changedDictionariesLocalIds: string[];\n  excludeKeys: string[];\n  hasRebuilt: boolean;\n}> => {\n  const appLogger = getAppLogger(configuration);\n\n  const unmergedDictionaries = readDictionariesFromDisk<\n    Record<string, Dictionary[]>\n  >(configuration.system.unmergedDictionariesDir);\n\n  const baseDir = configuration.system.baseDir;\n\n  const relativeFilePath = relative(baseDir, filePath);\n  const flatUnmergedDictionaries = Object.values(unmergedDictionaries).flat();\n\n  const filteredUnmergedDictionaries = flatUnmergedDictionaries.filter(\n    (dictionary) =>\n      dictionary.filePath === relativeFilePath &&\n      !keysToKeep.includes(dictionary.key)\n  );\n\n  // Deduplicate dictionaries by key\n  const uniqueUnmergedDictionaries = filteredUnmergedDictionaries.filter(\n    (dictionary, index, self) =>\n      index === self.findIndex((t) => t.key === dictionary.key)\n  );\n\n  const changedDictionariesLocalIds: string[] = [];\n  const filesToRemove: string[] = [];\n  const excludeKeys: string[] = [];\n\n  // Identify Unmerged Dictionaries to remove or clean\n  await Promise.all(\n    uniqueUnmergedDictionaries.map(async (dictionary) => {\n      const unmergedFilePath = normalize(\n        join(\n          configuration.system.unmergedDictionariesDir,\n          `${dictionary.key}.json`\n        )\n      );\n\n      try {\n        const jsonContent = await readFile(unmergedFilePath, 'utf8');\n        const parsedContent = JSON.parse(jsonContent);\n\n        if (parsedContent.length === 1) {\n          if (parsedContent[0].filePath === relativeFilePath) {\n            appLogger(\n              `Removing outdated dictionary ${colorizeKey(dictionary.key)}`,\n              { isVerbose: true }\n            );\n            filesToRemove.push(unmergedFilePath);\n            excludeKeys.push(dictionary.key);\n          }\n        } else {\n          const filteredContent = parsedContent.filter(\n            (content: any) => content.filePath !== relativeFilePath\n          );\n          await writeJsonIfChanged(unmergedFilePath, filteredContent);\n          changedDictionariesLocalIds.push(dictionary.localId!);\n        }\n      } catch (error: any) {\n        if (error.code === 'ENOENT') {\n          if (!excludeKeys.includes(dictionary.key)) {\n            excludeKeys.push(dictionary.key);\n          }\n        }\n      }\n    })\n  );\n\n  const dictionaries = readDictionariesFromDisk<Record<string, Dictionary>>(\n    configuration.system.dictionariesDir\n  );\n  const flatDictionaries = Object.values(dictionaries) as Dictionary[];\n\n  const filteredMergedDictionaries = flatDictionaries?.filter(\n    (dictionary) =>\n      !keysToKeep.includes(dictionary.key) &&\n      dictionary.localIds?.length === 1 &&\n      (dictionary.localIds[0] as string).endsWith(\n        `::local::${relativeFilePath}`\n      )\n  );\n\n  const uniqueMergedDictionaries = filteredMergedDictionaries.filter(\n    (dictionary, index, self) =>\n      index === self.findIndex((t) => t.key === dictionary.key)\n  );\n\n  // Identify Merged Dictionaries, Types, and Dynamic Dictionaries to remove\n  await Promise.all(\n    uniqueMergedDictionaries.map(async (dictionary) => {\n      const mergedFilePath = normalize(\n        join(configuration.system.dictionariesDir, `${dictionary.key}.json`)\n      );\n\n      try {\n        const fileContent = await readFile(mergedFilePath, 'utf8');\n        const parsedContent = JSON.parse(fileContent) as Dictionary;\n\n        if (parsedContent.localIds?.length === 1) {\n          if (\n            parsedContent.localIds[0].endsWith(`::local::${relativeFilePath}`)\n          ) {\n            appLogger(\n              `Removing outdated unmerged dictionary ${colorizeKey(dictionary.key)}`,\n              { isVerbose: true }\n            );\n\n            // Mark JSON for removal\n            filesToRemove.push(mergedFilePath);\n\n            // Mark TS Types for removal\n            const typesFilePath = normalize(\n              join(configuration.system.typesDir, `${dictionary.key}.ts`)\n            );\n            filesToRemove.push(typesFilePath);\n\n            // Mark Dynamic Dictionaries for removal\n            // We use glob to catch the loader files (.cjs, .mjs) AND the split locale files (.en.json, etc.)\n            const dynamicFilesGlob = join(\n              configuration.system.dynamicDictionariesDir,\n              `${dictionary.key}.*`\n            );\n            const dynamicFiles = await fg(normalizePath(dynamicFilesGlob), {\n              absolute: true,\n            });\n            filesToRemove.push(...dynamicFiles);\n\n            if (!excludeKeys.includes(dictionary.key)) {\n              excludeKeys.push(dictionary.key);\n            }\n          }\n        } else {\n          const localIds = parsedContent.localIds?.filter(\n            (localeId) => !localeId.endsWith(`::local::${relativeFilePath}`)\n          ) as string[];\n          const newContent = { ...parsedContent, localIds };\n          await writeJsonIfChanged(mergedFilePath, newContent);\n        }\n      } catch (error: any) {\n        if (error.code === 'ENOENT') {\n          if (!excludeKeys.includes(dictionary.key)) {\n            excludeKeys.push(dictionary.key);\n          }\n          const typesFilePath = normalize(\n            join(configuration.system.typesDir, `${dictionary.key}.ts`)\n          );\n          filesToRemove.push(typesFilePath);\n        }\n      }\n    })\n  );\n\n  // Execute Cleanup\n  if (filesToRemove.length > 0 || excludeKeys.length > 0) {\n    // Update entry points (indexes) first so the app doesn't import dead files\n    await createDictionaryEntryPoint(configuration, { excludeKeys });\n\n    // Remove the files synchronously (awaited) immediately after.\n    if (filesToRemove.length > 0) {\n      setTimeout(\n        async () =>\n          await Promise.all(\n            filesToRemove.map(async (path) => {\n              const relativePath = relative(baseDir, path);\n              try {\n                await rm(path, { force: true });\n\n                appLogger(`Deleted artifact: ${colorizePath(relativePath)}`, {\n                  isVerbose: true,\n                });\n              } catch {\n                appLogger(\n                  `Error while removing file ${colorizePath(relativePath)}`,\n                  {\n                    isVerbose: true,\n                  }\n                );\n              }\n            })\n          ),\n        3000\n      );\n    }\n  }\n\n  return {\n    changedDictionariesLocalIds,\n    excludeKeys,\n    hasRebuilt: filesToRemove.length > 0 || excludeKeys.length > 0,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;AAeA,MAAa,iCAAiC,OAC5C,UACA,YACA,kBAKI;CACJ,MAAM,sDAAyB,cAAc;CAE7C,MAAM,uBAAuBA,gEAE3B,cAAc,OAAO,wBAAwB;CAE/C,MAAM,UAAU,cAAc,OAAO;CAErC,MAAM,2CAA4B,SAAS,SAAS;CAUpD,MAAM,6BAT2B,OAAO,OAAO,qBAAqB,CAAC,MAER,CAAC,QAC3D,eACC,WAAW,aAAa,oBACxB,CAAC,WAAW,SAAS,WAAW,IAAI,CAIuB,CAAC,QAC7D,YAAY,OAAO,SAClB,UAAU,KAAK,WAAW,MAAM,EAAE,QAAQ,WAAW,IAAI,CAC5D;CAED,MAAM,8BAAwC,EAAE;CAChD,MAAM,gBAA0B,EAAE;CAClC,MAAM,cAAwB,EAAE;AAGhC,OAAM,QAAQ,IACZ,2BAA2B,IAAI,OAAO,eAAe;EACnD,MAAM,gEAEF,cAAc,OAAO,yBACrB,GAAG,WAAW,IAAI,OACnB,CACF;AAED,MAAI;GACF,MAAM,cAAc,qCAAe,kBAAkB,OAAO;GAC5D,MAAM,gBAAgB,KAAK,MAAM,YAAY;AAE7C,OAAI,cAAc,WAAW,GAC3B;QAAI,cAAc,GAAG,aAAa,kBAAkB;AAClD,eACE,yEAA4C,WAAW,IAAI,IAC3D,EAAE,WAAW,MAAM,CACpB;AACD,mBAAc,KAAK,iBAAiB;AACpC,iBAAY,KAAK,WAAW,IAAI;;UAE7B;AAIL,UAAMC,8CAAmB,kBAHD,cAAc,QACnC,YAAiB,QAAQ,aAAa,iBAEiB,CAAC;AAC3D,gCAA4B,KAAK,WAAW,QAAS;;WAEhD,OAAY;AACnB,OAAI,MAAM,SAAS,UACjB;QAAI,CAAC,YAAY,SAAS,WAAW,IAAI,CACvC,aAAY,KAAK,WAAW,IAAI;;;GAItC,CACH;CAED,MAAM,eAAeD,gEACnB,cAAc,OAAO,gBACtB;CAYD,MAAM,4BAXmB,OAAO,OAAO,aAEY,EAAE,QAClD,eACC,CAAC,WAAW,SAAS,WAAW,IAAI,IACpC,WAAW,UAAU,WAAW,KAC/B,WAAW,SAAS,GAAc,SACjC,YAAY,mBACb,CACJ,EAE2D,QACzD,YAAY,OAAO,SAClB,UAAU,KAAK,WAAW,MAAM,EAAE,QAAQ,WAAW,IAAI,CAC5D;AAGD,OAAM,QAAQ,IACZ,yBAAyB,IAAI,OAAO,eAAe;EACjD,MAAM,8DACC,cAAc,OAAO,iBAAiB,GAAG,WAAW,IAAI,OAAO,CACrE;AAED,MAAI;GACF,MAAM,cAAc,qCAAe,gBAAgB,OAAO;GAC1D,MAAM,gBAAgB,KAAK,MAAM,YAAY;AAE7C,OAAI,cAAc,UAAU,WAAW,GACrC;QACE,cAAc,SAAS,GAAG,SAAS,YAAY,mBAAmB,EAClE;AACA,eACE,kFAAqD,WAAW,IAAI,IACpE,EAAE,WAAW,MAAM,CACpB;AAGD,mBAAc,KAAK,eAAe;KAGlC,MAAM,6DACC,cAAc,OAAO,UAAU,GAAG,WAAW,IAAI,KAAK,CAC5D;AACD,mBAAc,KAAK,cAAc;KAQjC,MAAM,eAAe,4FAHnB,cAAc,OAAO,wBACrB,GAAG,WAAW,IAAI,IAEwC,CAAC,EAAE,EAC7D,UAAU,MACX,CAAC;AACF,mBAAc,KAAK,GAAG,aAAa;AAEnC,SAAI,CAAC,YAAY,SAAS,WAAW,IAAI,CACvC,aAAY,KAAK,WAAW,IAAI;;UAG/B;IACL,MAAM,WAAW,cAAc,UAAU,QACtC,aAAa,CAAC,SAAS,SAAS,YAAY,mBAAmB,CACjE;AAED,UAAMC,8CAAmB,gBAAgB;KADpB,GAAG;KAAe;KACY,CAAC;;WAE/C,OAAY;AACnB,OAAI,MAAM,SAAS,UAAU;AAC3B,QAAI,CAAC,YAAY,SAAS,WAAW,IAAI,CACvC,aAAY,KAAK,WAAW,IAAI;IAElC,MAAM,6DACC,cAAc,OAAO,UAAU,GAAG,WAAW,IAAI,KAAK,CAC5D;AACD,kBAAc,KAAK,cAAc;;;GAGrC,CACH;AAGD,KAAI,cAAc,SAAS,KAAK,YAAY,SAAS,GAAG;AAEtD,QAAMC,yFAA2B,eAAe,EAAE,aAAa,CAAC;AAGhE,MAAI,cAAc,SAAS,EACzB,YACE,YACE,MAAM,QAAQ,IACZ,cAAc,IAAI,OAAO,SAAS;GAChC,MAAM,uCAAwB,SAAS,KAAK;AAC5C,OAAI;AACF,mCAAS,MAAM,EAAE,OAAO,MAAM,CAAC;AAE/B,cAAU,+DAAkC,aAAa,IAAI,EAC3D,WAAW,MACZ,CAAC;WACI;AACN,cACE,uEAA0C,aAAa,IACvD,EACE,WAAW,MACZ,CACF;;IAEH,CACH,EACH,IACD;;AAIL,QAAO;EACL;EACA;EACA,YAAY,cAAc,SAAS,KAAK,YAAY,SAAS;EAC9D"}

package/dist/cjs/cli.cjs

@@ -0,0 +1,48 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_listProjects = require('./listProjects.cjs');
+const require_installLSP = require('./installLSP.cjs');
+const require_listDictionariesPath = require('./listDictionariesPath.cjs');
+const require_prepareIntlayer = require('./prepareIntlayer.cjs');
+const require_writeContentDeclaration_detectExportedComponentName = require('./writeContentDeclaration/detectExportedComponentName.cjs');
+const require_writeContentDeclaration_transformJSFile = require('./writeContentDeclaration/transformJSFile.cjs');
+const require_detectFormatCommand = require('./detectFormatCommand.cjs');
+const require_getContentDeclarationFileTemplate_getContentDeclarationFileTemplate = require('./getContentDeclarationFileTemplate/getContentDeclarationFileTemplate.cjs');
+const require_writeContentDeclaration_writeJSFile = require('./writeContentDeclaration/writeJSFile.cjs');
+const require_writeContentDeclaration_writeContentDeclaration = require('./writeContentDeclaration/writeContentDeclaration.cjs');
+const require_init_cms = require('./init/cms.cjs');
+const require_init_utils_packageManager = require('./init/utils/packageManager.cjs');
+const require_init_utils_nextCompilerBabel = require('./init/utils/nextCompilerBabel.cjs');
+const require_init_index = require('./init/index.cjs');
+const require_installSkills_index = require('./installSkills/index.cjs');
+const require_installMCP_installMCP = require('./installMCP/installMCP.cjs');
+const require_listGitFiles = require('./listGitFiles.cjs');
+const require_logConfigDetails = require('./logConfigDetails.cjs');
+
+exports.NEXT_INTLAYER_BABEL_CONFIG_CONTENT = require_init_utils_nextCompilerBabel.NEXT_INTLAYER_BABEL_CONFIG_CONTENT;
+exports.PLATFORMS = require_installSkills_index.PLATFORMS;
+exports.PLATFORMS_METADATA = require_installSkills_index.PLATFORMS_METADATA;
+exports.SKILLS = require_installSkills_index.SKILLS;
+exports.SKILLS_METADATA = require_installSkills_index.SKILLS_METADATA;
+exports.detectExportedComponentName = require_writeContentDeclaration_detectExportedComponentName.detectExportedComponentName;
+exports.detectFormatCommand = require_detectFormatCommand.detectFormatCommand;
+exports.detectPackageManager = require_init_utils_packageManager.detectPackageManager;
+exports.enableEditorInConfig = require_init_cms.enableEditorInConfig;
+exports.getContentDeclarationFileTemplate = require_getContentDeclarationFileTemplate_getContentDeclarationFileTemplate.getContentDeclarationFileTemplate;
+exports.getInitialSkills = require_installSkills_index.getInitialSkills;
+exports.initIntlayer = require_init_index.initIntlayer;
+exports.installLSP = require_installLSP.installLSP;
+exports.installMCP = require_installMCP_installMCP.installMCP;
+exports.installPackages = require_init_utils_packageManager.installPackages;
+exports.installSkills = require_installSkills_index.installSkills;
+exports.listDictionaries = require_listDictionariesPath.listDictionaries;
+exports.listDictionariesWithStats = require_listDictionariesPath.listDictionariesWithStats;
+exports.listGitFiles = require_listGitFiles.listGitFiles;
+exports.listGitLines = require_listGitFiles.listGitLines;
+exports.listProjects = require_listProjects.listProjects;
+exports.logConfigDetails = require_logConfigDetails.logConfigDetails;
+exports.prepareIntlayer = require_prepareIntlayer.prepareIntlayer;
+exports.setupCmsCredentials = require_init_cms.setupCmsCredentials;
+exports.transformJSFile = require_writeContentDeclaration_transformJSFile.transformJSFile;
+exports.writeCmsCredentialsToEnv = require_init_cms.writeCmsCredentialsToEnv;
+exports.writeContentDeclaration = require_writeContentDeclaration_writeContentDeclaration.writeContentDeclaration;
+exports.writeJSFile = require_writeContentDeclaration_writeJSFile.writeJSFile;

package/dist/cjs/createDictionaryEntryPoint/createDictionaryEntryPoint.cjs

@@ -0,0 +1,71 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_utils_parallelize = require('../utils/parallelize.cjs');
+const require_writeFileIfChanged = require('../writeFileIfChanged.cjs');
+const require_createDictionaryEntryPoint_generateDictionaryListContent = require('./generateDictionaryListContent.cjs');
+const require_createDictionaryEntryPoint_getBuiltDictionariesPath = require('./getBuiltDictionariesPath.cjs');
+const require_createDictionaryEntryPoint_getBuiltDynamicDictionariesPath = require('./getBuiltDynamicDictionariesPath.cjs');
+const require_createDictionaryEntryPoint_getBuiltFetchDictionariesPath = require('./getBuiltFetchDictionariesPath.cjs');
+const require_createDictionaryEntryPoint_getBuiltRemoteDictionariesPath = require('./getBuiltRemoteDictionariesPath.cjs');
+const require_createDictionaryEntryPoint_getBuiltUnmergedDictionariesPath = require('./getBuiltUnmergedDictionariesPath.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let _intlayer_config_node = require("@intlayer/config/node");
+
+//#region src/createDictionaryEntryPoint/createDictionaryEntryPoint.ts
+const writeDictionaryFiles = async (paths, fileName, importType, functionName, format, configuration = (0, _intlayer_config_node.getConfiguration)()) => {
+	const content = require_createDictionaryEntryPoint_generateDictionaryListContent.generateDictionaryListContent(await paths, functionName, importType, format, configuration);
+	const extension = format === "cjs" ? "cjs" : "mjs";
+	const { mainDir } = configuration.system;
+	await require_writeFileIfChanged.writeFileIfChanged((0, node_path.resolve)(mainDir, `${fileName}.${extension}`), content);
+};
+/**
+* This function generates a list of dictionaries in the main directory
+*/
+const createDictionaryEntryPoint = async (configuration = (0, _intlayer_config_node.getConfiguration)(), options = {}) => {
+	const { formats, excludeKeys = [] } = options;
+	const outputFormats = formats ?? configuration.build.outputFormat;
+	const { mainDir } = configuration.system;
+	await (0, node_fs_promises.mkdir)(mainDir, { recursive: true });
+	await require_utils_parallelize.parallelize([
+		...outputFormats.map((format) => ({
+			paths: require_createDictionaryEntryPoint_getBuiltDictionariesPath.getBuiltDictionariesPath(configuration, excludeKeys),
+			importType: "json",
+			functionName: "getDictionaries",
+			fileName: "dictionaries",
+			format
+		})),
+		...outputFormats.map((format) => ({
+			paths: require_createDictionaryEntryPoint_getBuiltUnmergedDictionariesPath.getBuiltUnmergedDictionariesPath(configuration, excludeKeys),
+			importType: "json",
+			functionName: "getUnmergedDictionaries",
+			fileName: "unmerged_dictionaries",
+			format
+		})),
+		...outputFormats.map((format) => ({
+			paths: require_createDictionaryEntryPoint_getBuiltDynamicDictionariesPath.getBuiltDynamicDictionariesPath(configuration, format, excludeKeys),
+			importType: "javascript",
+			functionName: "getDynamicDictionaries",
+			fileName: "dynamic_dictionaries",
+			format
+		})),
+		...outputFormats.map((format) => ({
+			paths: require_createDictionaryEntryPoint_getBuiltFetchDictionariesPath.getBuiltFetchDictionariesPath(configuration, format, excludeKeys),
+			importType: "javascript",
+			functionName: "getFetchDictionaries",
+			fileName: "fetch_dictionaries",
+			format
+		})),
+		...outputFormats.map((format) => ({
+			paths: require_createDictionaryEntryPoint_getBuiltRemoteDictionariesPath.getBuiltRemoteDictionariesPath(configuration, excludeKeys),
+			importType: "json",
+			functionName: "getRemoteDictionaries",
+			fileName: "remote_dictionaries",
+			format
+		}))
+	], async ({ paths, fileName, format, functionName, importType }) => await writeDictionaryFiles(paths, fileName, importType, functionName, format, configuration));
+};
+
+//#endregion
+exports.createDictionaryEntryPoint = createDictionaryEntryPoint;
+//# sourceMappingURL=createDictionaryEntryPoint.cjs.map

package/dist/cjs/createDictionaryEntryPoint/createDictionaryEntryPoint.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDictionaryEntryPoint.cjs","names":["generateDictionaryListContent","writeFileIfChanged","parallelize","getBuiltDictionariesPath","getBuiltUnmergedDictionariesPath","getBuiltDynamicDictionariesPath","getBuiltFetchDictionariesPath","getBuiltRemoteDictionariesPath"],"sources":["../../../src/createDictionaryEntryPoint/createDictionaryEntryPoint.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { getConfiguration } from '@intlayer/config/node';\nimport { parallelize } from '../utils/parallelize';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\nimport { generateDictionaryListContent } from './generateDictionaryListContent';\nimport { getBuiltDictionariesPath } from './getBuiltDictionariesPath';\nimport { getBuiltDynamicDictionariesPath } from './getBuiltDynamicDictionariesPath';\nimport { getBuiltFetchDictionariesPath } from './getBuiltFetchDictionariesPath';\nimport { getBuiltRemoteDictionariesPath } from './getBuiltRemoteDictionariesPath';\nimport { getBuiltUnmergedDictionariesPath } from './getBuiltUnmergedDictionariesPath';\n\nconst writeDictionaryFiles = async (\n  paths: Promise<string[]>,\n  fileName: string,\n  importType: 'json' | 'javascript',\n  functionName: string,\n  format: 'cjs' | 'esm',\n  configuration = getConfiguration()\n) => {\n  const resolvedPath = await paths;\n\n  const content = generateDictionaryListContent(\n    resolvedPath,\n    functionName,\n    importType,\n    format,\n    configuration\n  );\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n\n  const { mainDir } = configuration.system;\n\n  await writeFileIfChanged(\n    resolve(mainDir, `${fileName}.${extension}`),\n    content\n  );\n};\n\nexport type CreateDictionaryEntryPointOptions = {\n  formats?: ('cjs' | 'esm')[];\n  excludeKeys?: string[];\n};\n\n/**\n * This function generates a list of dictionaries in the main directory\n */\nexport const createDictionaryEntryPoint = async (\n  configuration = getConfiguration(),\n  options: CreateDictionaryEntryPointOptions = {}\n) => {\n  const { formats, excludeKeys = [] } = options;\n  const outputFormats = formats ?? configuration.build.outputFormat;\n  const { mainDir } = configuration.system;\n\n  await mkdir(mainDir, { recursive: true });\n\n  const writeOperations = [\n    ...outputFormats.map(\n      (format) =>\n        ({\n          paths: getBuiltDictionariesPath(configuration, excludeKeys),\n          importType: 'json',\n          functionName: 'getDictionaries',\n          fileName: 'dictionaries' as const,\n          format,\n        }) as const\n    ),\n    ...outputFormats.map(\n      (format) =>\n        ({\n          paths: getBuiltUnmergedDictionariesPath(configuration, excludeKeys),\n          importType: 'json',\n          functionName: 'getUnmergedDictionaries',\n          fileName: 'unmerged_dictionaries' as const,\n          format,\n        }) as const\n    ),\n    ...outputFormats.map(\n      (format) =>\n        ({\n          paths: getBuiltDynamicDictionariesPath(\n            configuration,\n            format,\n            excludeKeys\n          ),\n          importType: 'javascript',\n          functionName: 'getDynamicDictionaries',\n          fileName: 'dynamic_dictionaries' as const,\n          format,\n        }) as const\n    ),\n    ...outputFormats.map(\n      (format) =>\n        ({\n          paths: getBuiltFetchDictionariesPath(\n            configuration,\n            format,\n            excludeKeys\n          ),\n          importType: 'javascript',\n          functionName: 'getFetchDictionaries',\n          fileName: 'fetch_dictionaries' as const,\n          format,\n        }) as const\n    ),\n    ...outputFormats.map(\n      (format) =>\n        ({\n          paths: getBuiltRemoteDictionariesPath(configuration, excludeKeys),\n          importType: 'json',\n          functionName: 'getRemoteDictionaries',\n          fileName: 'remote_dictionaries' as const,\n          format,\n        }) as const\n    ),\n  ];\n\n  await parallelize(\n    writeOperations,\n    async ({ paths, fileName, format, functionName, importType }) =>\n      await writeDictionaryFiles(\n        paths,\n        fileName,\n        importType,\n        functionName,\n        format,\n        configuration\n      )\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;AAYA,MAAM,uBAAuB,OAC3B,OACA,UACA,YACA,cACA,QACA,6DAAkC,KAC/B;CAGH,MAAM,UAAUA,+FACd,MAHyB,OAIzB,cACA,YACA,QACA,cACD;CACD,MAAM,YAAY,WAAW,QAAQ,QAAQ;CAE7C,MAAM,EAAE,YAAY,cAAc;AAElC,OAAMC,qEACI,SAAS,GAAG,SAAS,GAAG,YAAY,EAC5C,QACD;;;;;AAWH,MAAa,6BAA6B,OACxC,6DAAkC,EAClC,UAA6C,EAAE,KAC5C;CACH,MAAM,EAAE,SAAS,cAAc,EAAE,KAAK;CACtC,MAAM,gBAAgB,WAAW,cAAc,MAAM;CACrD,MAAM,EAAE,YAAY,cAAc;AAElC,mCAAY,SAAS,EAAE,WAAW,MAAM,CAAC;AA+DzC,OAAMC,sCACJ;EA7DA,GAAG,cAAc,KACd,YACE;GACC,OAAOC,qFAAyB,eAAe,YAAY;GAC3D,YAAY;GACZ,cAAc;GACd,UAAU;GACV;GACD,EACJ;EACD,GAAG,cAAc,KACd,YACE;GACC,OAAOC,qGAAiC,eAAe,YAAY;GACnE,YAAY;GACZ,cAAc;GACd,UAAU;GACV;GACD,EACJ;EACD,GAAG,cAAc,KACd,YACE;GACC,OAAOC,mGACL,eACA,QACA,YACD;GACD,YAAY;GACZ,cAAc;GACd,UAAU;GACV;GACD,EACJ;EACD,GAAG,cAAc,KACd,YACE;GACC,OAAOC,+FACL,eACA,QACA,YACD;GACD,YAAY;GACZ,cAAc;GACd,UAAU;GACV;GACD,EACJ;EACD,GAAG,cAAc,KACd,YACE;GACC,OAAOC,iGAA+B,eAAe,YAAY;GACjE,YAAY;GACZ,cAAc;GACd,UAAU;GACV;GACD,EACJ;EAIc,EACf,OAAO,EAAE,OAAO,UAAU,QAAQ,cAAc,iBAC9C,MAAM,qBACJ,OACA,UACA,YACA,cACA,QACA,cACD,CACJ"}

package/dist/cjs/createDictionaryEntryPoint/generateDictionaryListContent.cjs

@@ -0,0 +1,43 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_utils_getPathHash = require('../utils/getPathHash.cjs');
+let node_path = require("node:path");
+let _intlayer_config_node = require("@intlayer/config/node");
+let _intlayer_config_utils = require("@intlayer/config/utils");
+
+//#region src/createDictionaryEntryPoint/generateDictionaryListContent.ts
+/**
+* This function generates the content of the dictionary list file
+*/
+const generateDictionaryListContent = (dictionaries, functionName, importType, format = "esm", configuration = (0, _intlayer_config_node.getConfiguration)()) => {
+	const { mainDir } = configuration.system;
+	let content = "";
+	const dictionariesRef = dictionaries.map((dictionaryPath) => ({
+		relativePath: (0, _intlayer_config_utils.normalizePath)((0, node_path.relative)(mainDir, dictionaryPath)),
+		id: (0, node_path.basename)(dictionaryPath, (0, node_path.extname)(dictionaryPath)),
+		hash: `_${require_utils_getPathHash.getPathHash(dictionaryPath)}`
+	}));
+	dictionariesRef.forEach((dictionary) => {
+		if (format === "esm") content += `import ${dictionary.hash} from '${dictionary.relativePath}'${importType === "json" ? " with { type: 'json' }" : ""};\n`;
+		if (format === "cjs") content += `const ${dictionary.hash} = require('${dictionary.relativePath}');\n`;
+	});
+	content += "\n";
+	const formattedDictionaryMap = dictionariesRef.map((dictionary) => `  "${dictionary.id}": ${dictionary.hash}`).join(",\n");
+	content += `const dictionaries = {\n${formattedDictionaryMap}\n};\n`;
+	content += `const ${functionName} = () => dictionaries;\n`;
+	if (format === "esm") {
+		content += `\n`;
+		content += `export { ${functionName} };\n`;
+		content += `export default dictionaries;\n`;
+	}
+	if (format === "cjs") {
+		content += `\n`;
+		content += `module.exports.${functionName} = ${functionName};\n`;
+		content += `module.exports = dictionaries;\n`;
+	}
+	return content;
+};
+
+//#endregion
+exports.generateDictionaryListContent = generateDictionaryListContent;
+//# sourceMappingURL=generateDictionaryListContent.cjs.map

package/dist/cjs/createDictionaryEntryPoint/generateDictionaryListContent.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateDictionaryListContent.cjs","names":["getPathHash"],"sources":["../../../src/createDictionaryEntryPoint/generateDictionaryListContent.ts"],"sourcesContent":["import { basename, extname, relative } from 'node:path';\nimport { getConfiguration } from '@intlayer/config/node';\nimport { normalizePath } from '@intlayer/config/utils';\nimport { getPathHash } from '../utils/getPathHash';\n\n/**\n * This function generates the content of the dictionary list file\n */\nexport const generateDictionaryListContent = (\n  dictionaries: string[],\n  functionName: string,\n  importType: 'json' | 'javascript',\n  format: 'cjs' | 'esm' = 'esm',\n  configuration = getConfiguration()\n): string => {\n  const { mainDir } = configuration.system;\n\n  let content = '';\n\n  const dictionariesRef = dictionaries.map((dictionaryPath) => ({\n    relativePath: normalizePath(relative(mainDir, dictionaryPath)),\n    id: basename(dictionaryPath, extname(dictionaryPath)), // Get the base name as the dictionary id\n    hash: `_${getPathHash(dictionaryPath)}`, // Get the hash of the dictionary to avoid conflicts\n  }));\n\n  dictionariesRef.forEach((dictionary) => {\n    if (format === 'esm')\n      content += `import ${dictionary.hash} from '${dictionary.relativePath}'${importType === 'json' ? \" with { type: 'json' }\" : ''};\\n`;\n    if (format === 'cjs')\n      content += `const ${dictionary.hash} = require('${dictionary.relativePath}');\\n`;\n  });\n\n  content += '\\n';\n\n  // Format Dictionary Map\n  const formattedDictionaryMap: string = dictionariesRef\n    .map((dictionary) => `  \"${dictionary.id}\": ${dictionary.hash}`)\n    .join(',\\n');\n\n  content += `const dictionaries = {\\n${formattedDictionaryMap}\\n};\\n`;\n  content += `const ${functionName} = () => dictionaries;\\n`;\n\n  if (format === 'esm') {\n    content += `\\n`;\n    content += `export { ${functionName} };\\n`;\n    content += `export default dictionaries;\\n`;\n  }\n\n  if (format === 'cjs') {\n    content += `\\n`;\n    content += `module.exports.${functionName} = ${functionName};\\n`;\n    content += `module.exports = dictionaries;\\n`;\n  }\n\n  return content;\n};\n"],"mappings":";;;;;;;;;;;AAQA,MAAa,iCACX,cACA,cACA,YACA,SAAwB,OACxB,6DAAkC,KACvB;CACX,MAAM,EAAE,YAAY,cAAc;CAElC,IAAI,UAAU;CAEd,MAAM,kBAAkB,aAAa,KAAK,oBAAoB;EAC5D,gFAAqC,SAAS,eAAe,CAAC;EAC9D,4BAAa,uCAAwB,eAAe,CAAC;EACrD,MAAM,IAAIA,sCAAY,eAAe;EACtC,EAAE;AAEH,iBAAgB,SAAS,eAAe;AACtC,MAAI,WAAW,MACb,YAAW,UAAU,WAAW,KAAK,SAAS,WAAW,aAAa,GAAG,eAAe,SAAS,2BAA2B,GAAG;AACjI,MAAI,WAAW,MACb,YAAW,SAAS,WAAW,KAAK,cAAc,WAAW,aAAa;GAC5E;AAEF,YAAW;CAGX,MAAM,yBAAiC,gBACpC,KAAK,eAAe,MAAM,WAAW,GAAG,KAAK,WAAW,OAAO,CAC/D,KAAK,MAAM;AAEd,YAAW,2BAA2B,uBAAuB;AAC7D,YAAW,SAAS,aAAa;AAEjC,KAAI,WAAW,OAAO;AACpB,aAAW;AACX,aAAW,YAAY,aAAa;AACpC,aAAW;;AAGb,KAAI,WAAW,OAAO;AACpB,aAAW;AACX,aAAW,kBAAkB,aAAa,KAAK,aAAa;AAC5D,aAAW;;AAGb,QAAO"}

package/dist/cjs/createDictionaryEntryPoint/getBuiltDictionariesPath.cjs

@@ -0,0 +1,25 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let fast_glob = require("fast-glob");
+fast_glob = require_runtime.__toESM(fast_glob);
+let node_fs = require("node:fs");
+let _intlayer_config_utils = require("@intlayer/config/utils");
+
+//#region src/createDictionaryEntryPoint/getBuiltDictionariesPath.ts
+/**
+* This function generates a list of dictionaries in the main directory
+*/
+const getBuiltDictionariesPath = async (configuration, excludeKeys = []) => {
+	const { dictionariesDir, mainDir } = configuration.system;
+	if (!(0, node_fs.existsSync)(mainDir)) await (0, node_fs_promises.mkdir)(mainDir, { recursive: true });
+	return (await (0, fast_glob.default)(`${(0, _intlayer_config_utils.normalizePath)(dictionariesDir)}/**/*.json`)).filter((path) => {
+		const key = (0, node_path.basename)(path, ".json");
+		return !excludeKeys.includes(key);
+	});
+};
+
+//#endregion
+exports.getBuiltDictionariesPath = getBuiltDictionariesPath;
+//# sourceMappingURL=getBuiltDictionariesPath.cjs.map

package/dist/cjs/createDictionaryEntryPoint/getBuiltDictionariesPath.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getBuiltDictionariesPath.cjs","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltDictionariesPath.ts"],"sourcesContent":["import { existsSync } from 'node:fs';\nimport { mkdir } from 'node:fs/promises';\nimport { basename } from 'node:path';\nimport { normalizePath } from '@intlayer/config/utils';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport fg from 'fast-glob';\n\n/**\n * This function generates a list of dictionaries in the main directory\n */\nexport const getBuiltDictionariesPath = async (\n  configuration: IntlayerConfig,\n  excludeKeys: string[] = []\n) => {\n  const { dictionariesDir, mainDir } = configuration.system;\n\n  // Create main directory if it doesn't exist\n  if (!existsSync(mainDir)) {\n    await mkdir(mainDir, { recursive: true });\n  }\n\n  const dictionariesPath: string[] = await fg(\n    `${normalizePath(dictionariesDir)}/**/*.json`\n  );\n\n  return dictionariesPath.filter((path) => {\n    const key = basename(path, '.json');\n    return !excludeKeys.includes(key);\n  });\n};\n"],"mappings":";;;;;;;;;;;;;AAUA,MAAa,2BAA2B,OACtC,eACA,cAAwB,EAAE,KACvB;CACH,MAAM,EAAE,iBAAiB,YAAY,cAAc;AAGnD,KAAI,yBAAY,QAAQ,CACtB,mCAAY,SAAS,EAAE,WAAW,MAAM,CAAC;AAO3C,SAAO,6BAHL,6CAAiB,gBAAgB,CAAC,YACnC,EAEuB,QAAQ,SAAS;EACvC,MAAM,8BAAe,MAAM,QAAQ;AACnC,SAAO,CAAC,YAAY,SAAS,IAAI;GACjC"}

package/dist/cjs/createDictionaryEntryPoint/getBuiltDynamicDictionariesPath.cjs

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let fast_glob = require("fast-glob");
+fast_glob = require_runtime.__toESM(fast_glob);
+let node_fs = require("node:fs");
+let _intlayer_config_utils = require("@intlayer/config/utils");
+
+//#region src/createDictionaryEntryPoint/getBuiltDynamicDictionariesPath.ts
+/**
+* This function generates a list of dictionaries in the main directory
+*/
+const getBuiltDynamicDictionariesPath = async (configuration, format = "esm", excludeKeys = []) => {
+	const { dynamicDictionariesDir, mainDir } = configuration.system;
+	if (!(0, node_fs.existsSync)(mainDir)) await (0, node_fs_promises.mkdir)(mainDir, { recursive: true });
+	const extension = format === "cjs" ? "cjs" : "mjs";
+	return (await (0, fast_glob.default)(`${(0, _intlayer_config_utils.normalizePath)(dynamicDictionariesDir)}/*.${extension}`)).filter((path) => {
+		const key = (0, node_path.basename)(path, `.${extension}`);
+		return !excludeKeys.includes(key);
+	});
+};
+
+//#endregion
+exports.getBuiltDynamicDictionariesPath = getBuiltDynamicDictionariesPath;
+//# sourceMappingURL=getBuiltDynamicDictionariesPath.cjs.map

package/dist/cjs/createDictionaryEntryPoint/getBuiltDynamicDictionariesPath.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getBuiltDynamicDictionariesPath.cjs","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltDynamicDictionariesPath.ts"],"sourcesContent":["import { existsSync } from 'node:fs';\nimport { mkdir } from 'node:fs/promises';\nimport { basename } from 'node:path';\nimport { normalizePath } from '@intlayer/config/utils';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport fg from 'fast-glob';\n\n/**\n * This function generates a list of dictionaries in the main directory\n */\nexport const getBuiltDynamicDictionariesPath = async (\n  configuration: IntlayerConfig,\n  format: 'cjs' | 'esm' = 'esm',\n  excludeKeys: string[] = []\n) => {\n  const { dynamicDictionariesDir, mainDir } = configuration.system;\n\n  // Create main directory if it doesn't exist\n  if (!existsSync(mainDir)) {\n    await mkdir(mainDir, { recursive: true });\n  }\n\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n\n  const dictionariesPath: string[] = await fg(\n    `${normalizePath(dynamicDictionariesDir)}/*.${extension}`\n  );\n\n  return dictionariesPath.filter((path) => {\n    const key = basename(path, `.${extension}`);\n    return !excludeKeys.includes(key);\n  });\n};\n"],"mappings":";;;;;;;;;;;;;AAUA,MAAa,kCAAkC,OAC7C,eACA,SAAwB,OACxB,cAAwB,EAAE,KACvB;CACH,MAAM,EAAE,wBAAwB,YAAY,cAAc;AAG1D,KAAI,yBAAY,QAAQ,CACtB,mCAAY,SAAS,EAAE,WAAW,MAAM,CAAC;CAG3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;AAM7C,SAAO,6BAHL,6CAAiB,uBAAuB,CAAC,KAAK,YAC/C,EAEuB,QAAQ,SAAS;EACvC,MAAM,8BAAe,MAAM,IAAI,YAAY;AAC3C,SAAO,CAAC,YAAY,SAAS,IAAI;GACjC"}

package/dist/cjs/createDictionaryEntryPoint/getBuiltFetchDictionariesPath.cjs

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let fast_glob = require("fast-glob");
+fast_glob = require_runtime.__toESM(fast_glob);
+let node_fs = require("node:fs");
+let _intlayer_config_utils = require("@intlayer/config/utils");
+
+//#region src/createDictionaryEntryPoint/getBuiltFetchDictionariesPath.ts
+/**
+* This function generates a list of dictionaries in the main directory
+*/
+const getBuiltFetchDictionariesPath = async (configuration, format = "esm", excludeKeys = []) => {
+	const { fetchDictionariesDir, mainDir } = configuration.system;
+	if (!(0, node_fs.existsSync)(mainDir)) await (0, node_fs_promises.mkdir)(mainDir, { recursive: true });
+	const extension = format === "cjs" ? "cjs" : "mjs";
+	return (await (0, fast_glob.default)(`${(0, _intlayer_config_utils.normalizePath)(fetchDictionariesDir)}/*.${extension}`)).filter((path) => {
+		const key = (0, node_path.basename)(path, `.${extension}`);
+		return !excludeKeys.includes(key);
+	});
+};
+
+//#endregion
+exports.getBuiltFetchDictionariesPath = getBuiltFetchDictionariesPath;
+//# sourceMappingURL=getBuiltFetchDictionariesPath.cjs.map

package/dist/cjs/createDictionaryEntryPoint/getBuiltFetchDictionariesPath.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getBuiltFetchDictionariesPath.cjs","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltFetchDictionariesPath.ts"],"sourcesContent":["import { existsSync } from 'node:fs';\nimport { mkdir } from 'node:fs/promises';\nimport { basename } from 'node:path';\nimport { normalizePath } from '@intlayer/config/utils';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport fg from 'fast-glob';\n\n/**\n * This function generates a list of dictionaries in the main directory\n */\nexport const getBuiltFetchDictionariesPath = async (\n  configuration: IntlayerConfig,\n  format: 'cjs' | 'esm' = 'esm',\n  excludeKeys: string[] = []\n) => {\n  const { fetchDictionariesDir, mainDir } = configuration.system;\n\n  // Create main directory if it doesn't exist\n  if (!existsSync(mainDir)) {\n    await mkdir(mainDir, { recursive: true });\n  }\n\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n\n  const dictionariesPath: string[] = await fg(\n    `${normalizePath(fetchDictionariesDir)}/*.${extension}`\n  );\n\n  return dictionariesPath.filter((path) => {\n    const key = basename(path, `.${extension}`);\n    return !excludeKeys.includes(key);\n  });\n};\n"],"mappings":";;;;;;;;;;;;;AAUA,MAAa,gCAAgC,OAC3C,eACA,SAAwB,OACxB,cAAwB,EAAE,KACvB;CACH,MAAM,EAAE,sBAAsB,YAAY,cAAc;AAGxD,KAAI,yBAAY,QAAQ,CACtB,mCAAY,SAAS,EAAE,WAAW,MAAM,CAAC;CAG3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;AAM7C,SAAO,6BAHL,6CAAiB,qBAAqB,CAAC,KAAK,YAC7C,EAEuB,QAAQ,SAAS;EACvC,MAAM,8BAAe,MAAM,IAAI,YAAY;AAC3C,SAAO,CAAC,YAAY,SAAS,IAAI;GACjC"}

package/dist/cjs/createDictionaryEntryPoint/getBuiltRemoteDictionariesPath.cjs

@@ -0,0 +1,25 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let fast_glob = require("fast-glob");
+fast_glob = require_runtime.__toESM(fast_glob);
+let node_fs = require("node:fs");
+let _intlayer_config_utils = require("@intlayer/config/utils");
+
+//#region src/createDictionaryEntryPoint/getBuiltRemoteDictionariesPath.ts
+/**
+* This function generates a list of dictionaries in the main directory
+*/
+const getBuiltRemoteDictionariesPath = async (configuration, excludeKeys = []) => {
+	const { remoteDictionariesDir, mainDir } = configuration.system;
+	if (!(0, node_fs.existsSync)(mainDir)) await (0, node_fs_promises.mkdir)(mainDir, { recursive: true });
+	return fast_glob.default.sync(`${(0, _intlayer_config_utils.normalizePath)(remoteDictionariesDir)}/**/*.json`).filter((path) => {
+		const key = (0, node_path.basename)(path, ".json");
+		return !excludeKeys.includes(key);
+	});
+};
+
+//#endregion
+exports.getBuiltRemoteDictionariesPath = getBuiltRemoteDictionariesPath;
+//# sourceMappingURL=getBuiltRemoteDictionariesPath.cjs.map