@intlayer/chokidar 7.5.0-canary.0 → 7.5.0

package/dist/cjs/buildIntlayerDictionary/buildIntlayerDictionary.cjs

@@ -3,18 +3,18 @@ const require_buildIntlayerDictionary_writeDynamicDictionary = require('./writeD
 const require_buildIntlayerDictionary_writeFetchDictionary = require('./writeFetchDictionary.cjs');
 const require_buildIntlayerDictionary_writeMergedDictionary = require('./writeMergedDictionary.cjs');
 const require_buildIntlayerDictionary_writeUnmergedDictionary = require('./writeUnmergedDictionary.cjs');
-let __intlayer_config = require("@intlayer/config");
-let __intlayer_unmerged_dictionaries_entry = require("@intlayer/unmerged-dictionaries-entry");
+let _intlayer_config = require("@intlayer/config");
+let _intlayer_unmerged_dictionaries_entry = require("@intlayer/unmerged-dictionaries-entry");
 
 //#region src/buildIntlayerDictionary/buildIntlayerDictionary.ts
 /**
 * This function transpile the bundled code to to make dictionaries as JSON files
 */
-const buildDictionary = async (localDictionariesEntries, configuration = (0, __intlayer_config.getConfiguration)(), formats = ["cjs", "esm"], importOtherDictionaries = true) => {
+const buildDictionary = async (localDictionariesEntries, configuration = (0, _intlayer_config.getConfiguration)(), formats = ["cjs", "esm"], importOtherDictionaries = true) => {
 	const { importMode } = configuration.build;
 	const unmergedDictionariesToUpdate = [...localDictionariesEntries];
 	if (importOtherDictionaries) {
-		const prevUnmergedDictionaries = (0, __intlayer_unmerged_dictionaries_entry.getUnmergedDictionaries)(configuration);
+		const prevUnmergedDictionaries = (0, _intlayer_unmerged_dictionaries_entry.getUnmergedDictionaries)(configuration);
 		for (const dictionaryToWrite of localDictionariesEntries) {
 			const allPrebuiltUnmergedDictionaries = prevUnmergedDictionaries[dictionaryToWrite.key];
 			if (allPrebuiltUnmergedDictionaries?.length > 0) {

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

@@ -1 +1 @@
-{"version":3,"file":"buildIntlayerDictionary.cjs","names":["unmergedDictionariesToUpdate: Dictionary[]","prevUnmergedDictionaries: Record<string, Dictionary[]>","writeUnmergedDictionaries","writeMergedDictionaries","dynamicDictionaries: LocalizedDictionaryOutput | null","writeDynamicDictionary","fetchDictionaries: LocalizedDictionaryOutput | null","writeFetchDictionary"],"sources":["../../../src/buildIntlayerDictionary/buildIntlayerDictionary.ts"],"sourcesContent":["import { getConfiguration } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/types';\nimport { getUnmergedDictionaries } from '@intlayer/unmerged-dictionaries-entry';\nimport {\n  type LocalizedDictionaryOutput,\n  writeDynamicDictionary,\n} from './writeDynamicDictionary';\nimport { writeFetchDictionary } from './writeFetchDictionary';\nimport { writeMergedDictionaries } from './writeMergedDictionary';\nimport { writeUnmergedDictionaries } from './writeUnmergedDictionary';\n\n/**\n * This function transpile the bundled code to to make dictionaries as JSON files\n */\nexport const buildDictionary = async (\n  localDictionariesEntries: Dictionary[],\n  configuration = getConfiguration(),\n  formats: ('cjs' | 'esm')[] = ['cjs', 'esm'],\n  importOtherDictionaries = true\n) => {\n  const { importMode } = configuration.build;\n\n  const unmergedDictionariesToUpdate: Dictionary[] = [\n    ...localDictionariesEntries,\n  ];\n\n  if (importOtherDictionaries) {\n    const prevUnmergedDictionaries: Record<string, Dictionary[]> =\n      getUnmergedDictionaries(configuration);\n\n    // Reinsert other dictionaries with the same key to avoid merging errors\n    for (const dictionaryToWrite of localDictionariesEntries) {\n      const allPrebuiltUnmergedDictionaries =\n        prevUnmergedDictionaries[dictionaryToWrite.key];\n\n      if (allPrebuiltUnmergedDictionaries?.length > 0) {\n        // Do not add the same dictionary again by filtering out the one with the same localId\n        const otherUnmergedDictionaries =\n          allPrebuiltUnmergedDictionaries.filter(\n            (unmergedDictionary) =>\n              unmergedDictionary.localId !== dictionaryToWrite.localId\n          );\n\n        unmergedDictionariesToUpdate.push(...otherUnmergedDictionaries);\n      }\n    }\n  }\n\n  const unmergedDictionaries = await writeUnmergedDictionaries(\n    unmergedDictionariesToUpdate,\n    configuration\n  );\n\n  const mergedDictionaries = await writeMergedDictionaries(\n    unmergedDictionaries,\n    configuration\n  );\n\n  let dynamicDictionaries: LocalizedDictionaryOutput | null = null;\n\n  if (importMode === 'dynamic' || importMode === 'live') {\n    dynamicDictionaries = await writeDynamicDictionary(\n      mergedDictionaries,\n      configuration,\n      formats\n    );\n  }\n\n  let fetchDictionaries: LocalizedDictionaryOutput | null = null;\n\n  if (importMode === 'live') {\n    fetchDictionaries = await writeFetchDictionary(\n      dynamicDictionaries!,\n      configuration,\n      formats\n    );\n  }\n\n  return {\n    unmergedDictionaries,\n    mergedDictionaries,\n    dynamicDictionaries,\n    fetchDictionaries,\n  };\n};\n"],"mappings":";;;;;;;;;;;;AAcA,MAAa,kBAAkB,OAC7B,0BACA,yDAAkC,EAClC,UAA6B,CAAC,OAAO,MAAM,EAC3C,0BAA0B,SACvB;CACH,MAAM,EAAE,eAAe,cAAc;CAErC,MAAMA,+BAA6C,CACjD,GAAG,yBACJ;AAED,KAAI,yBAAyB;EAC3B,MAAMC,+FACoB,cAAc;AAGxC,OAAK,MAAM,qBAAqB,0BAA0B;GACxD,MAAM,kCACJ,yBAAyB,kBAAkB;AAE7C,OAAI,iCAAiC,SAAS,GAAG;IAE/C,MAAM,4BACJ,gCAAgC,QAC7B,uBACC,mBAAmB,YAAY,kBAAkB,QACpD;AAEH,iCAA6B,KAAK,GAAG,0BAA0B;;;;CAKrE,MAAM,uBAAuB,MAAMC,kFACjC,8BACA,cACD;CAED,MAAM,qBAAqB,MAAMC,8EAC/B,sBACA,cACD;CAED,IAAIC,sBAAwD;AAE5D,KAAI,eAAe,aAAa,eAAe,OAC7C,uBAAsB,MAAMC,8EAC1B,oBACA,eACA,QACD;CAGH,IAAIC,oBAAsD;AAE1D,KAAI,eAAe,OACjB,qBAAoB,MAAMC,0EACxB,qBACA,eACA,QACD;AAGH,QAAO;EACL;EACA;EACA;EACA;EACD"}
+{"version":3,"file":"buildIntlayerDictionary.cjs","names":["unmergedDictionariesToUpdate: Dictionary[]","prevUnmergedDictionaries: Record<string, Dictionary[]>","writeUnmergedDictionaries","writeMergedDictionaries","dynamicDictionaries: LocalizedDictionaryOutput | null","writeDynamicDictionary","fetchDictionaries: LocalizedDictionaryOutput | null","writeFetchDictionary"],"sources":["../../../src/buildIntlayerDictionary/buildIntlayerDictionary.ts"],"sourcesContent":["import { getConfiguration } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/types';\nimport { getUnmergedDictionaries } from '@intlayer/unmerged-dictionaries-entry';\nimport {\n  type LocalizedDictionaryOutput,\n  writeDynamicDictionary,\n} from './writeDynamicDictionary';\nimport { writeFetchDictionary } from './writeFetchDictionary';\nimport { writeMergedDictionaries } from './writeMergedDictionary';\nimport { writeUnmergedDictionaries } from './writeUnmergedDictionary';\n\n/**\n * This function transpile the bundled code to to make dictionaries as JSON files\n */\nexport const buildDictionary = async (\n  localDictionariesEntries: Dictionary[],\n  configuration = getConfiguration(),\n  formats: ('cjs' | 'esm')[] = ['cjs', 'esm'],\n  importOtherDictionaries = true\n) => {\n  const { importMode } = configuration.build;\n\n  const unmergedDictionariesToUpdate: Dictionary[] = [\n    ...localDictionariesEntries,\n  ];\n\n  if (importOtherDictionaries) {\n    const prevUnmergedDictionaries: Record<string, Dictionary[]> =\n      getUnmergedDictionaries(configuration);\n\n    // Reinsert other dictionaries with the same key to avoid merging errors\n    for (const dictionaryToWrite of localDictionariesEntries) {\n      const allPrebuiltUnmergedDictionaries =\n        prevUnmergedDictionaries[dictionaryToWrite.key];\n\n      if (allPrebuiltUnmergedDictionaries?.length > 0) {\n        // Do not add the same dictionary again by filtering out the one with the same localId\n        const otherUnmergedDictionaries =\n          allPrebuiltUnmergedDictionaries.filter(\n            (unmergedDictionary) =>\n              unmergedDictionary.localId !== dictionaryToWrite.localId\n          );\n\n        unmergedDictionariesToUpdate.push(...otherUnmergedDictionaries);\n      }\n    }\n  }\n\n  const unmergedDictionaries = await writeUnmergedDictionaries(\n    unmergedDictionariesToUpdate,\n    configuration\n  );\n\n  const mergedDictionaries = await writeMergedDictionaries(\n    unmergedDictionaries,\n    configuration\n  );\n\n  let dynamicDictionaries: LocalizedDictionaryOutput | null = null;\n\n  if (importMode === 'dynamic' || importMode === 'live') {\n    dynamicDictionaries = await writeDynamicDictionary(\n      mergedDictionaries,\n      configuration,\n      formats\n    );\n  }\n\n  let fetchDictionaries: LocalizedDictionaryOutput | null = null;\n\n  if (importMode === 'live') {\n    fetchDictionaries = await writeFetchDictionary(\n      dynamicDictionaries!,\n      configuration,\n      formats\n    );\n  }\n\n  return {\n    unmergedDictionaries,\n    mergedDictionaries,\n    dynamicDictionaries,\n    fetchDictionaries,\n  };\n};\n"],"mappings":";;;;;;;;;;;;AAcA,MAAa,kBAAkB,OAC7B,0BACA,wDAAkC,EAClC,UAA6B,CAAC,OAAO,MAAM,EAC3C,0BAA0B,SACvB;CACH,MAAM,EAAE,eAAe,cAAc;CAErC,MAAMA,+BAA6C,CACjD,GAAG,yBACJ;AAED,KAAI,yBAAyB;EAC3B,MAAMC,8FACoB,cAAc;AAGxC,OAAK,MAAM,qBAAqB,0BAA0B;GACxD,MAAM,kCACJ,yBAAyB,kBAAkB;AAE7C,OAAI,iCAAiC,SAAS,GAAG;IAE/C,MAAM,4BACJ,gCAAgC,QAC7B,uBACC,mBAAmB,YAAY,kBAAkB,QACpD;AAEH,iCAA6B,KAAK,GAAG,0BAA0B;;;;CAKrE,MAAM,uBAAuB,MAAMC,kFACjC,8BACA,cACD;CAED,MAAM,qBAAqB,MAAMC,8EAC/B,sBACA,cACD;CAED,IAAIC,sBAAwD;AAE5D,KAAI,eAAe,aAAa,eAAe,OAC7C,uBAAsB,MAAMC,8EAC1B,oBACA,eACA,QACD;CAGH,IAAIC,oBAAsD;AAE1D,KAAI,eAAe,OACjB,qBAAoB,MAAMC,0EACxB,qBACA,eACA,QACD;AAGH,QAAO;EACL;EACA;EACA;EACA;EACD"}

package/dist/cjs/buildIntlayerDictionary/processContentDeclaration.cjs

@@ -1,6 +1,6 @@
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 const require_utils_resolveObjectPromises = require('../utils/resolveObjectPromises.cjs');
-let __intlayer_config_client = require("@intlayer/config/client");
+let _intlayer_config_client = require("@intlayer/config/client");
 
 //#region src/buildIntlayerDictionary/processContentDeclaration.ts
 /**
@@ -14,7 +14,7 @@ const processContentDeclaration = async (contentDeclaration) => {
 			content
 		};
 	} catch (error) {
-		(0, __intlayer_config_client.logger)(error, { level: "error" });
+		(0, _intlayer_config_client.logger)(error, { level: "error" });
 	}
 };
 

package/dist/cjs/buildIntlayerDictionary/processContentDeclaration.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"processContentDeclaration.cjs","names":["resolveObjectPromises"],"sources":["../../../src/buildIntlayerDictionary/processContentDeclaration.ts"],"sourcesContent":["import { logger } from '@intlayer/config/client';\nimport type { Dictionary } from '@intlayer/types';\nimport { resolveObjectPromises } from '../utils/resolveObjectPromises';\n\n/**\n * Function to load, process the module and return the Intlayer Dictionary from the module file\n */\nexport const processContentDeclaration = async (\n  contentDeclaration: Dictionary\n): Promise<Dictionary | undefined> => {\n  try {\n    const content = (await resolveObjectPromises(\n      contentDeclaration.content\n    )) as Dictionary['content'];\n\n    return {\n      ...contentDeclaration,\n      content,\n    } as Dictionary;\n  } catch (error) {\n    logger(error, {\n      level: 'error',\n    });\n  }\n};\n"],"mappings":";;;;;;;;AAOA,MAAa,4BAA4B,OACvC,uBACoC;AACpC,KAAI;EACF,MAAM,UAAW,MAAMA,0DACrB,mBAAmB,QACpB;AAED,SAAO;GACL,GAAG;GACH;GACD;UACM,OAAO;AACd,uCAAO,OAAO,EACZ,OAAO,SACR,CAAC"}
+{"version":3,"file":"processContentDeclaration.cjs","names":["resolveObjectPromises"],"sources":["../../../src/buildIntlayerDictionary/processContentDeclaration.ts"],"sourcesContent":["import { logger } from '@intlayer/config/client';\nimport type { Dictionary } from '@intlayer/types';\nimport { resolveObjectPromises } from '../utils/resolveObjectPromises';\n\n/**\n * Function to load, process the module and return the Intlayer Dictionary from the module file\n */\nexport const processContentDeclaration = async (\n  contentDeclaration: Dictionary\n): Promise<Dictionary | undefined> => {\n  try {\n    const content = (await resolveObjectPromises(\n      contentDeclaration.content\n    )) as Dictionary['content'];\n\n    return {\n      ...contentDeclaration,\n      content,\n    } as Dictionary;\n  } catch (error) {\n    logger(error, {\n      level: 'error',\n    });\n  }\n};\n"],"mappings":";;;;;;;;AAOA,MAAa,4BAA4B,OACvC,uBACoC;AACpC,KAAI;EACF,MAAM,UAAW,MAAMA,0DACrB,mBAAmB,QACpB;AAED,SAAO;GACL,GAAG;GACH;GACD;UACM,OAAO;AACd,sCAAO,OAAO,EACZ,OAAO,SACR,CAAC"}

package/dist/cjs/buildIntlayerDictionary/writeDynamicDictionary.cjs

@@ -3,19 +3,19 @@ const require_utils_parallelize = require('../utils/parallelize.cjs');
 const require_writeFileIfChanged = require('../writeFileIfChanged.cjs');
 const require_writeJsonIfChanged = require('../writeJsonIfChanged.cjs');
 let node_fs_promises = require("node:fs/promises");
-let __intlayer_config = require("@intlayer/config");
+let _intlayer_config = require("@intlayer/config");
 let node_path = require("node:path");
-let __intlayer_core = require("@intlayer/core");
+let _intlayer_core = require("@intlayer/core");
 
 //#region src/buildIntlayerDictionary/writeDynamicDictionary.ts
 /**
 * This function generates the content of the dictionary list file
 */
-const generateDictionaryEntryPoint = (localizedDictionariesPathsRecord, format = "esm", configuration = (0, __intlayer_config.getConfiguration)()) => {
+const generateDictionaryEntryPoint = (localizedDictionariesPathsRecord, format = "esm", configuration = (0, _intlayer_config.getConfiguration)()) => {
 	const { dynamicDictionariesDir } = configuration.content;
 	let content = "";
 	const formattedDictionaryMap = Object.entries(localizedDictionariesPathsRecord).filter((entry) => Boolean(entry[1])).sort(([a], [b]) => String(a).localeCompare(String(b))).map(([locale, dictionary]) => {
-		const relativePath = (0, __intlayer_config.normalizePath)((0, node_path.relative)(dynamicDictionariesDir, dictionary.dictionaryPath));
+		const relativePath = (0, _intlayer_config.normalizePath)((0, node_path.relative)(dynamicDictionariesDir, dictionary.dictionaryPath));
 		if (format === "esm") return `  '${locale}': () => import('./${relativePath}', { assert: { type: 'json' }}).then(mod => mod.default)`;
 		return `  '${locale}': () => Promise.resolve(require('./${relativePath}'))`;
 	}).join(",\n");
@@ -40,7 +40,7 @@ const generateDictionaryEntryPoint = (localizedDictionariesPathsRecord, format =
 * // { key: 'home', content: { ... } },
 * ```
 */
-const writeDynamicDictionary = async (mergedDictionaries, configuration = (0, __intlayer_config.getConfiguration)(), formats = ["cjs", "esm"]) => {
+const writeDynamicDictionary = async (mergedDictionaries, configuration = (0, _intlayer_config.getConfiguration)(), formats = ["cjs", "esm"]) => {
 	const { locales, defaultLocale } = configuration.internationalization;
 	const { dynamicDictionariesDir } = configuration.content;
 	await (0, node_fs_promises.mkdir)((0, node_path.resolve)(dynamicDictionariesDir), { recursive: true });
@@ -49,7 +49,7 @@ const writeDynamicDictionary = async (mergedDictionaries, configuration = (0, __
 		if (key === "undefined") return;
 		const localizedDictionariesPathsRecord = {};
 		await require_utils_parallelize.parallelize(locales, async (locale) => {
-			const localizedDictionary = (0, __intlayer_core.getPerLocaleDictionary)(dictionaryEntry.dictionary, locale, defaultLocale);
+			const localizedDictionary = (0, _intlayer_core.getPerLocaleDictionary)(dictionaryEntry.dictionary, locale, defaultLocale);
 			const outputFileName = `${key}.${locale}.json`;
 			const resultFilePath = (0, node_path.resolve)(dynamicDictionariesDir, outputFileName);
 			await require_writeJsonIfChanged.writeJsonIfChanged(resultFilePath, localizedDictionary).catch((err) => {
@@ -65,7 +65,7 @@ const writeDynamicDictionary = async (mergedDictionaries, configuration = (0, __
 			const extension = format === "cjs" ? "cjs" : "mjs";
 			const content = generateDictionaryEntryPoint(localizedDictionariesPathsRecord, format, configuration);
 			await require_writeFileIfChanged.writeFileIfChanged((0, node_path.resolve)(dynamicDictionariesDir, `${key}.${extension}`), content).catch((err) => {
-				console.error(`Error creating dynamic ${(0, __intlayer_config.colorizePath)((0, node_path.resolve)(dynamicDictionariesDir, `${key}.${extension}`))}:`, err);
+				console.error(`Error creating dynamic ${(0, _intlayer_config.colorizePath)((0, node_path.resolve)(dynamicDictionariesDir, `${key}.${extension}`))}:`, err);
 			});
 		});
 	});

package/dist/cjs/buildIntlayerDictionary/writeDynamicDictionary.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"writeDynamicDictionary.cjs","names":["formattedDictionaryMap: string","resultDictionariesPaths: LocalizedDictionaryOutput","parallelize","localizedDictionariesPathsRecord: LocalizedDictionaryResult","writeJsonIfChanged","writeFileIfChanged"],"sources":["../../../src/buildIntlayerDictionary/writeDynamicDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { relative, resolve } from 'node:path';\nimport {\n  colorizePath,\n  getConfiguration,\n  normalizePath,\n} from '@intlayer/config';\nimport { getPerLocaleDictionary } from '@intlayer/core';\nimport type { Dictionary, Locale } from '@intlayer/types';\nimport { parallelize } from '../utils/parallelize';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\nimport { writeJsonIfChanged } from '../writeJsonIfChanged';\nimport type { MergedDictionaryOutput } from './writeMergedDictionary';\n\nexport type DictionaryResult = {\n  dictionaryPath: string;\n  dictionary: Dictionary;\n};\n\nexport type LocalizedDictionaryResult = Partial<\n  Record<Locale, DictionaryResult>\n>;\n\nexport type LocalizedDictionaryOutput = Record<\n  string,\n  LocalizedDictionaryResult\n>;\n\n/**\n * This function generates the content of the dictionary list file\n */\nexport const generateDictionaryEntryPoint = (\n  localizedDictionariesPathsRecord: LocalizedDictionaryResult,\n  format: 'cjs' | 'esm' = 'esm',\n  configuration = getConfiguration()\n): string => {\n  const { dynamicDictionariesDir } = configuration.content;\n\n  let content = '';\n\n  // Format Dictionary Map - map locales to functions\n  const formattedDictionaryMap: string = Object.entries(\n    localizedDictionariesPathsRecord\n  )\n    // The following filter/sort preserve determinism of the generated map\n    // when files are built in parallel or across different Node versions.\n    .filter((entry): entry is [string, DictionaryResult] => Boolean(entry[1]))\n    .sort(([a], [b]) => String(a).localeCompare(String(b)))\n    .map(([locale, dictionary]) => {\n      const relativePath = normalizePath(\n        relative(dynamicDictionariesDir, dictionary.dictionaryPath)\n      );\n\n      if (format === 'esm') {\n        return `  '${locale}': () => import('./${relativePath}', { assert: { type: 'json' }}).then(mod => mod.default)`;\n      }\n\n      return `  '${locale}': () => Promise.resolve(require('./${relativePath}'))`;\n    })\n    .join(',\\n');\n\n  content += `const content = {\\n${formattedDictionaryMap}\\n};\\n`;\n\n  if (format === 'esm') content += `export default content;\\n`;\n  if (format === 'cjs') content += `module.exports = content;\\n`;\n\n  return content;\n};\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/dynamic_dictionaries/home.json\n * // { key: 'home', content: { ... } },\n * ```\n */\nexport const writeDynamicDictionary = async (\n  mergedDictionaries: MergedDictionaryOutput,\n  configuration = getConfiguration(),\n  formats: ('cjs' | 'esm')[] = ['cjs', 'esm']\n): Promise<LocalizedDictionaryOutput> => {\n  const { locales, defaultLocale } = configuration.internationalization;\n  const { dynamicDictionariesDir } = configuration.content;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(dynamicDictionariesDir), { recursive: true });\n\n  const resultDictionariesPaths: LocalizedDictionaryOutput = {};\n\n  // Merge dictionaries with the same key and write to dictionariesDir\n  await parallelize(\n    Object.entries(mergedDictionaries).sort(([a], [b]) =>\n      String(a).localeCompare(String(b))\n    ),\n    async ([key, dictionaryEntry]) => {\n      if (key === 'undefined') return;\n\n      const localizedDictionariesPathsRecord: LocalizedDictionaryResult = {};\n\n      await parallelize(locales, async (locale) => {\n        const localizedDictionary = getPerLocaleDictionary(\n          dictionaryEntry.dictionary,\n          locale,\n          defaultLocale\n        );\n\n        const outputFileName = `${key}.${locale}.json`;\n        const resultFilePath = resolve(dynamicDictionariesDir, outputFileName);\n\n        // Write the localized dictionary\n        await writeJsonIfChanged(resultFilePath, localizedDictionary).catch(\n          (err) => {\n            console.error(`Error creating localized ${outputFileName}:`, err);\n          }\n        );\n\n        localizedDictionariesPathsRecord[locale] = {\n          dictionaryPath: resultFilePath,\n          dictionary: localizedDictionary,\n        };\n      });\n\n      resultDictionariesPaths[key] = localizedDictionariesPathsRecord;\n\n      await parallelize(formats, async (format) => {\n        const extension = format === 'cjs' ? 'cjs' : 'mjs';\n        const content = generateDictionaryEntryPoint(\n          localizedDictionariesPathsRecord,\n          format,\n          configuration\n        );\n\n        await writeFileIfChanged(\n          resolve(dynamicDictionariesDir, `${key}.${extension}`),\n          content\n        ).catch((err) => {\n          console.error(\n            `Error creating dynamic ${colorizePath(resolve(dynamicDictionariesDir, `${key}.${extension}`))}:`,\n            err\n          );\n        });\n      });\n    }\n  );\n\n  return resultDictionariesPaths;\n};\n"],"mappings":";;;;;;;;;;;;;AA+BA,MAAa,gCACX,kCACA,SAAwB,OACxB,yDAAkC,KACvB;CACX,MAAM,EAAE,2BAA2B,cAAc;CAEjD,IAAI,UAAU;CAGd,MAAMA,yBAAiC,OAAO,QAC5C,iCACD,CAGE,QAAQ,UAA+C,QAAQ,MAAM,GAAG,CAAC,CACzE,MAAM,CAAC,IAAI,CAAC,OAAO,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CAAC,CACtD,KAAK,CAAC,QAAQ,gBAAgB;EAC7B,MAAM,4EACK,wBAAwB,WAAW,eAAe,CAC5D;AAED,MAAI,WAAW,MACb,QAAO,MAAM,OAAO,qBAAqB,aAAa;AAGxD,SAAO,MAAM,OAAO,sCAAsC,aAAa;GACvE,CACD,KAAK,MAAM;AAEd,YAAW,sBAAsB,uBAAuB;AAExD,KAAI,WAAW,MAAO,YAAW;AACjC,KAAI,WAAW,MAAO,YAAW;AAEjC,QAAO;;;;;;;;;;;;;;;;;;AAmBT,MAAa,yBAAyB,OACpC,oBACA,yDAAkC,EAClC,UAA6B,CAAC,OAAO,MAAM,KACJ;CACvC,MAAM,EAAE,SAAS,kBAAkB,cAAc;CACjD,MAAM,EAAE,2BAA2B,cAAc;AAGjD,0DAAoB,uBAAuB,EAAE,EAAE,WAAW,MAAM,CAAC;CAEjE,MAAMC,0BAAqD,EAAE;AAG7D,OAAMC,sCACJ,OAAO,QAAQ,mBAAmB,CAAC,MAAM,CAAC,IAAI,CAAC,OAC7C,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CACnC,EACD,OAAO,CAAC,KAAK,qBAAqB;AAChC,MAAI,QAAQ,YAAa;EAEzB,MAAMC,mCAA8D,EAAE;AAEtE,QAAMD,sCAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,kEACJ,gBAAgB,YAChB,QACA,cACD;GAED,MAAM,iBAAiB,GAAG,IAAI,GAAG,OAAO;GACxC,MAAM,wCAAyB,wBAAwB,eAAe;AAGtE,SAAME,8CAAmB,gBAAgB,oBAAoB,CAAC,OAC3D,QAAQ;AACP,YAAQ,MAAM,4BAA4B,eAAe,IAAI,IAAI;KAEpE;AAED,oCAAiC,UAAU;IACzC,gBAAgB;IAChB,YAAY;IACb;IACD;AAEF,0BAAwB,OAAO;AAE/B,QAAMF,sCAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;GAC7C,MAAM,UAAU,6BACd,kCACA,QACA,cACD;AAED,SAAMG,qEACI,wBAAwB,GAAG,IAAI,GAAG,YAAY,EACtD,QACD,CAAC,OAAO,QAAQ;AACf,YAAQ,MACN,qFAA+C,wBAAwB,GAAG,IAAI,GAAG,YAAY,CAAC,CAAC,IAC/F,IACD;KACD;IACF;GAEL;AAED,QAAO"}
+{"version":3,"file":"writeDynamicDictionary.cjs","names":["formattedDictionaryMap: string","resultDictionariesPaths: LocalizedDictionaryOutput","parallelize","localizedDictionariesPathsRecord: LocalizedDictionaryResult","writeJsonIfChanged","writeFileIfChanged"],"sources":["../../../src/buildIntlayerDictionary/writeDynamicDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { relative, resolve } from 'node:path';\nimport {\n  colorizePath,\n  getConfiguration,\n  normalizePath,\n} from '@intlayer/config';\nimport { getPerLocaleDictionary } from '@intlayer/core';\nimport type { Dictionary, Locale } from '@intlayer/types';\nimport { parallelize } from '../utils/parallelize';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\nimport { writeJsonIfChanged } from '../writeJsonIfChanged';\nimport type { MergedDictionaryOutput } from './writeMergedDictionary';\n\nexport type DictionaryResult = {\n  dictionaryPath: string;\n  dictionary: Dictionary;\n};\n\nexport type LocalizedDictionaryResult = Partial<\n  Record<Locale, DictionaryResult>\n>;\n\nexport type LocalizedDictionaryOutput = Record<\n  string,\n  LocalizedDictionaryResult\n>;\n\n/**\n * This function generates the content of the dictionary list file\n */\nexport const generateDictionaryEntryPoint = (\n  localizedDictionariesPathsRecord: LocalizedDictionaryResult,\n  format: 'cjs' | 'esm' = 'esm',\n  configuration = getConfiguration()\n): string => {\n  const { dynamicDictionariesDir } = configuration.content;\n\n  let content = '';\n\n  // Format Dictionary Map - map locales to functions\n  const formattedDictionaryMap: string = Object.entries(\n    localizedDictionariesPathsRecord\n  )\n    // The following filter/sort preserve determinism of the generated map\n    // when files are built in parallel or across different Node versions.\n    .filter((entry): entry is [string, DictionaryResult] => Boolean(entry[1]))\n    .sort(([a], [b]) => String(a).localeCompare(String(b)))\n    .map(([locale, dictionary]) => {\n      const relativePath = normalizePath(\n        relative(dynamicDictionariesDir, dictionary.dictionaryPath)\n      );\n\n      if (format === 'esm') {\n        return `  '${locale}': () => import('./${relativePath}', { assert: { type: 'json' }}).then(mod => mod.default)`;\n      }\n\n      return `  '${locale}': () => Promise.resolve(require('./${relativePath}'))`;\n    })\n    .join(',\\n');\n\n  content += `const content = {\\n${formattedDictionaryMap}\\n};\\n`;\n\n  if (format === 'esm') content += `export default content;\\n`;\n  if (format === 'cjs') content += `module.exports = content;\\n`;\n\n  return content;\n};\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/dynamic_dictionaries/home.json\n * // { key: 'home', content: { ... } },\n * ```\n */\nexport const writeDynamicDictionary = async (\n  mergedDictionaries: MergedDictionaryOutput,\n  configuration = getConfiguration(),\n  formats: ('cjs' | 'esm')[] = ['cjs', 'esm']\n): Promise<LocalizedDictionaryOutput> => {\n  const { locales, defaultLocale } = configuration.internationalization;\n  const { dynamicDictionariesDir } = configuration.content;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(dynamicDictionariesDir), { recursive: true });\n\n  const resultDictionariesPaths: LocalizedDictionaryOutput = {};\n\n  // Merge dictionaries with the same key and write to dictionariesDir\n  await parallelize(\n    Object.entries(mergedDictionaries).sort(([a], [b]) =>\n      String(a).localeCompare(String(b))\n    ),\n    async ([key, dictionaryEntry]) => {\n      if (key === 'undefined') return;\n\n      const localizedDictionariesPathsRecord: LocalizedDictionaryResult = {};\n\n      await parallelize(locales, async (locale) => {\n        const localizedDictionary = getPerLocaleDictionary(\n          dictionaryEntry.dictionary,\n          locale,\n          defaultLocale\n        );\n\n        const outputFileName = `${key}.${locale}.json`;\n        const resultFilePath = resolve(dynamicDictionariesDir, outputFileName);\n\n        // Write the localized dictionary\n        await writeJsonIfChanged(resultFilePath, localizedDictionary).catch(\n          (err) => {\n            console.error(`Error creating localized ${outputFileName}:`, err);\n          }\n        );\n\n        localizedDictionariesPathsRecord[locale] = {\n          dictionaryPath: resultFilePath,\n          dictionary: localizedDictionary,\n        };\n      });\n\n      resultDictionariesPaths[key] = localizedDictionariesPathsRecord;\n\n      await parallelize(formats, async (format) => {\n        const extension = format === 'cjs' ? 'cjs' : 'mjs';\n        const content = generateDictionaryEntryPoint(\n          localizedDictionariesPathsRecord,\n          format,\n          configuration\n        );\n\n        await writeFileIfChanged(\n          resolve(dynamicDictionariesDir, `${key}.${extension}`),\n          content\n        ).catch((err) => {\n          console.error(\n            `Error creating dynamic ${colorizePath(resolve(dynamicDictionariesDir, `${key}.${extension}`))}:`,\n            err\n          );\n        });\n      });\n    }\n  );\n\n  return resultDictionariesPaths;\n};\n"],"mappings":";;;;;;;;;;;;;AA+BA,MAAa,gCACX,kCACA,SAAwB,OACxB,wDAAkC,KACvB;CACX,MAAM,EAAE,2BAA2B,cAAc;CAEjD,IAAI,UAAU;CAGd,MAAMA,yBAAiC,OAAO,QAC5C,iCACD,CAGE,QAAQ,UAA+C,QAAQ,MAAM,GAAG,CAAC,CACzE,MAAM,CAAC,IAAI,CAAC,OAAO,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CAAC,CACtD,KAAK,CAAC,QAAQ,gBAAgB;EAC7B,MAAM,2EACK,wBAAwB,WAAW,eAAe,CAC5D;AAED,MAAI,WAAW,MACb,QAAO,MAAM,OAAO,qBAAqB,aAAa;AAGxD,SAAO,MAAM,OAAO,sCAAsC,aAAa;GACvE,CACD,KAAK,MAAM;AAEd,YAAW,sBAAsB,uBAAuB;AAExD,KAAI,WAAW,MAAO,YAAW;AACjC,KAAI,WAAW,MAAO,YAAW;AAEjC,QAAO;;;;;;;;;;;;;;;;;;AAmBT,MAAa,yBAAyB,OACpC,oBACA,wDAAkC,EAClC,UAA6B,CAAC,OAAO,MAAM,KACJ;CACvC,MAAM,EAAE,SAAS,kBAAkB,cAAc;CACjD,MAAM,EAAE,2BAA2B,cAAc;AAGjD,0DAAoB,uBAAuB,EAAE,EAAE,WAAW,MAAM,CAAC;CAEjE,MAAMC,0BAAqD,EAAE;AAG7D,OAAMC,sCACJ,OAAO,QAAQ,mBAAmB,CAAC,MAAM,CAAC,IAAI,CAAC,OAC7C,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CACnC,EACD,OAAO,CAAC,KAAK,qBAAqB;AAChC,MAAI,QAAQ,YAAa;EAEzB,MAAMC,mCAA8D,EAAE;AAEtE,QAAMD,sCAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,iEACJ,gBAAgB,YAChB,QACA,cACD;GAED,MAAM,iBAAiB,GAAG,IAAI,GAAG,OAAO;GACxC,MAAM,wCAAyB,wBAAwB,eAAe;AAGtE,SAAME,8CAAmB,gBAAgB,oBAAoB,CAAC,OAC3D,QAAQ;AACP,YAAQ,MAAM,4BAA4B,eAAe,IAAI,IAAI;KAEpE;AAED,oCAAiC,UAAU;IACzC,gBAAgB;IAChB,YAAY;IACb;IACD;AAEF,0BAAwB,OAAO;AAE/B,QAAMF,sCAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;GAC7C,MAAM,UAAU,6BACd,kCACA,QACA,cACD;AAED,SAAMG,qEACI,wBAAwB,GAAG,IAAI,GAAG,YAAY,EACtD,QACD,CAAC,OAAO,QAAQ;AACf,YAAQ,MACN,oFAA+C,wBAAwB,GAAG,IAAI,GAAG,YAAY,CAAC,CAAC,IAC/F,IACD;KACD;IACF;GAEL;AAED,QAAO"}

package/dist/cjs/buildIntlayerDictionary/writeFetchDictionary.cjs

@@ -2,19 +2,19 @@ const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 const require_utils_parallelize = require('../utils/parallelize.cjs');
 const require_writeFileIfChanged = require('../writeFileIfChanged.cjs');
 let node_fs_promises = require("node:fs/promises");
-let __intlayer_config = require("@intlayer/config");
+let _intlayer_config = require("@intlayer/config");
 let node_path = require("node:path");
 
 //#region src/buildIntlayerDictionary/writeFetchDictionary.ts
 /**
 * This function generates the content of the dictionary list file
 */
-const generateDictionaryEntryPoint = (localedDictionariesPathsRecord, format = "esm", configuration = (0, __intlayer_config.getConfiguration)()) => {
+const generateDictionaryEntryPoint = (localedDictionariesPathsRecord, format = "esm", configuration = (0, _intlayer_config.getConfiguration)()) => {
 	const { fetchDictionariesDir } = configuration.content;
 	const { liveSyncURL } = configuration.editor;
 	let content = "";
 	const formattedDictionaryMap = Object.entries(localedDictionariesPathsRecord).map(([locale, dictionary]) => {
-		const relativePath = (0, __intlayer_config.normalizePath)((0, node_path.relative)(fetchDictionariesDir, dictionary.dictionaryPath));
+		const relativePath = (0, _intlayer_config.normalizePath)((0, node_path.relative)(fetchDictionariesDir, dictionary.dictionaryPath));
 		if (format === "esm") return `  '${locale}': () => (async () => { try {return await fetch('${liveSyncURL}/dictionaries/${dictionary.dictionary.key}/${locale}').then(res => res.json())} catch (_error) {return await import('./${relativePath}', { assert: { type: 'json' }}).then(mod => mod.default)}})()`;
 		return `  '${locale}': () => (async () => { try {return await fetch('${liveSyncURL}/dictionaries/${dictionary.dictionary.key}/${locale}').then(res => res.json())} catch (_error) {return Promise.resolve(require('./${relativePath}'))}})()`;
 	}).join(",\n");
@@ -39,7 +39,7 @@ const generateDictionaryEntryPoint = (localedDictionariesPathsRecord, format = "
 * // { key: 'home', content: { ... } },
 * ```
 */
-const writeFetchDictionary = async (dynamicDictionaries, configuration = (0, __intlayer_config.getConfiguration)(), formats = ["cjs", "esm"]) => {
+const writeFetchDictionary = async (dynamicDictionaries, configuration = (0, _intlayer_config.getConfiguration)(), formats = ["cjs", "esm"]) => {
 	const { fetchDictionariesDir } = configuration.content;
 	await (0, node_fs_promises.mkdir)((0, node_path.resolve)(fetchDictionariesDir), { recursive: true });
 	const resultDictionariesPaths = {};
@@ -49,7 +49,7 @@ const writeFetchDictionary = async (dynamicDictionaries, configuration = (0, __i
 			const extension = format === "cjs" ? "cjs" : "mjs";
 			const content = generateDictionaryEntryPoint(localedDictionariesPathsRecord, format, configuration);
 			await require_writeFileIfChanged.writeFileIfChanged((0, node_path.resolve)(fetchDictionariesDir, `${key}.${extension}`), content).catch((err) => {
-				console.error(`Error creating fetch ${(0, __intlayer_config.colorizePath)((0, node_path.resolve)(fetchDictionariesDir, `${key}.${extension}`))}:`, err);
+				console.error(`Error creating fetch ${(0, _intlayer_config.colorizePath)((0, node_path.resolve)(fetchDictionariesDir, `${key}.${extension}`))}:`, err);
 			});
 		});
 	});

package/dist/cjs/buildIntlayerDictionary/writeFetchDictionary.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"writeFetchDictionary.cjs","names":["formattedDictionaryMap: string","resultDictionariesPaths: LocalizedDictionaryOutput","parallelize","writeFileIfChanged"],"sources":["../../../src/buildIntlayerDictionary/writeFetchDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { relative, resolve } from 'node:path';\nimport {\n  colorizePath,\n  getConfiguration,\n  normalizePath,\n} from '@intlayer/config';\nimport { parallelize } from '../utils/parallelize';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\nimport type {\n  LocalizedDictionaryOutput,\n  LocalizedDictionaryResult,\n} from './writeDynamicDictionary';\n\n/**\n * This function generates the content of the dictionary list file\n */\nexport const generateDictionaryEntryPoint = (\n  localedDictionariesPathsRecord: LocalizedDictionaryResult,\n  format: 'cjs' | 'esm' = 'esm',\n  configuration = getConfiguration()\n): string => {\n  const { fetchDictionariesDir } = configuration.content;\n  const { liveSyncURL } = configuration.editor;\n\n  let content = '';\n\n  const formattedDictionaryMap: string = Object.entries(\n    localedDictionariesPathsRecord\n  )\n    .map(([locale, dictionary]) => {\n      const relativePath = normalizePath(\n        relative(fetchDictionariesDir, dictionary.dictionaryPath)\n      );\n\n      if (format === 'esm') {\n        return `  '${locale}': () => (async () => { try {return await fetch('${liveSyncURL}/dictionaries/${dictionary.dictionary.key}/${locale}').then(res => res.json())} catch (_error) {return await import('./${relativePath}', { assert: { type: 'json' }}).then(mod => mod.default)}})()`;\n      }\n\n      return `  '${locale}': () => (async () => { try {return await fetch('${liveSyncURL}/dictionaries/${dictionary.dictionary.key}/${locale}').then(res => res.json())} catch (_error) {return Promise.resolve(require('./${relativePath}'))}})()`;\n    })\n    .join(',\\n');\n\n  content += `const content = {\\n${formattedDictionaryMap}\\n};\\n`;\n\n  if (format === 'esm') content += `export default content;\\n`;\n  if (format === 'cjs') content += `module.exports = content;\\n`;\n\n  return content;\n};\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 writeFetchDictionary = async (\n  dynamicDictionaries: LocalizedDictionaryOutput,\n  configuration = getConfiguration(),\n  formats: ('cjs' | 'esm')[] = ['cjs', 'esm']\n): Promise<LocalizedDictionaryOutput> => {\n  const { fetchDictionariesDir } = configuration.content;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(fetchDictionariesDir), { recursive: true });\n\n  const resultDictionariesPaths: LocalizedDictionaryOutput = {};\n\n  // Write entry points for each dictionary in parallel\n  await parallelize(\n    Object.entries(dynamicDictionaries),\n    async ([key, localedDictionariesPathsRecord]) => {\n      if (key === 'undefined') return;\n\n      await parallelize(formats, async (format) => {\n        const extension = format === 'cjs' ? 'cjs' : 'mjs';\n        const content = generateDictionaryEntryPoint(\n          localedDictionariesPathsRecord,\n          format,\n          configuration\n        );\n\n        await writeFileIfChanged(\n          resolve(fetchDictionariesDir, `${key}.${extension}`),\n          content\n        ).catch((err) => {\n          console.error(\n            `Error creating fetch ${colorizePath(resolve(fetchDictionariesDir, `${key}.${extension}`))}:`,\n            err\n          );\n        });\n      });\n    }\n  );\n\n  return resultDictionariesPaths;\n};\n"],"mappings":";;;;;;;;;;;AAiBA,MAAa,gCACX,gCACA,SAAwB,OACxB,yDAAkC,KACvB;CACX,MAAM,EAAE,yBAAyB,cAAc;CAC/C,MAAM,EAAE,gBAAgB,cAAc;CAEtC,IAAI,UAAU;CAEd,MAAMA,yBAAiC,OAAO,QAC5C,+BACD,CACE,KAAK,CAAC,QAAQ,gBAAgB;EAC7B,MAAM,4EACK,sBAAsB,WAAW,eAAe,CAC1D;AAED,MAAI,WAAW,MACb,QAAO,MAAM,OAAO,mDAAmD,YAAY,gBAAgB,WAAW,WAAW,IAAI,GAAG,OAAO,qEAAqE,aAAa;AAG3N,SAAO,MAAM,OAAO,mDAAmD,YAAY,gBAAgB,WAAW,WAAW,IAAI,GAAG,OAAO,gFAAgF,aAAa;GACpO,CACD,KAAK,MAAM;AAEd,YAAW,sBAAsB,uBAAuB;AAExD,KAAI,WAAW,MAAO,YAAW;AACjC,KAAI,WAAW,MAAO,YAAW;AAEjC,QAAO;;;;;;;;;;;;;;;;;;AAmBT,MAAa,uBAAuB,OAClC,qBACA,yDAAkC,EAClC,UAA6B,CAAC,OAAO,MAAM,KACJ;CACvC,MAAM,EAAE,yBAAyB,cAAc;AAG/C,0DAAoB,qBAAqB,EAAE,EAAE,WAAW,MAAM,CAAC;CAE/D,MAAMC,0BAAqD,EAAE;AAG7D,OAAMC,sCACJ,OAAO,QAAQ,oBAAoB,EACnC,OAAO,CAAC,KAAK,oCAAoC;AAC/C,MAAI,QAAQ,YAAa;AAEzB,QAAMA,sCAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;GAC7C,MAAM,UAAU,6BACd,gCACA,QACA,cACD;AAED,SAAMC,qEACI,sBAAsB,GAAG,IAAI,GAAG,YAAY,EACpD,QACD,CAAC,OAAO,QAAQ;AACf,YAAQ,MACN,mFAA6C,sBAAsB,GAAG,IAAI,GAAG,YAAY,CAAC,CAAC,IAC3F,IACD;KACD;IACF;GAEL;AAED,QAAO"}
+{"version":3,"file":"writeFetchDictionary.cjs","names":["formattedDictionaryMap: string","resultDictionariesPaths: LocalizedDictionaryOutput","parallelize","writeFileIfChanged"],"sources":["../../../src/buildIntlayerDictionary/writeFetchDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { relative, resolve } from 'node:path';\nimport {\n  colorizePath,\n  getConfiguration,\n  normalizePath,\n} from '@intlayer/config';\nimport { parallelize } from '../utils/parallelize';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\nimport type {\n  LocalizedDictionaryOutput,\n  LocalizedDictionaryResult,\n} from './writeDynamicDictionary';\n\n/**\n * This function generates the content of the dictionary list file\n */\nexport const generateDictionaryEntryPoint = (\n  localedDictionariesPathsRecord: LocalizedDictionaryResult,\n  format: 'cjs' | 'esm' = 'esm',\n  configuration = getConfiguration()\n): string => {\n  const { fetchDictionariesDir } = configuration.content;\n  const { liveSyncURL } = configuration.editor;\n\n  let content = '';\n\n  const formattedDictionaryMap: string = Object.entries(\n    localedDictionariesPathsRecord\n  )\n    .map(([locale, dictionary]) => {\n      const relativePath = normalizePath(\n        relative(fetchDictionariesDir, dictionary.dictionaryPath)\n      );\n\n      if (format === 'esm') {\n        return `  '${locale}': () => (async () => { try {return await fetch('${liveSyncURL}/dictionaries/${dictionary.dictionary.key}/${locale}').then(res => res.json())} catch (_error) {return await import('./${relativePath}', { assert: { type: 'json' }}).then(mod => mod.default)}})()`;\n      }\n\n      return `  '${locale}': () => (async () => { try {return await fetch('${liveSyncURL}/dictionaries/${dictionary.dictionary.key}/${locale}').then(res => res.json())} catch (_error) {return Promise.resolve(require('./${relativePath}'))}})()`;\n    })\n    .join(',\\n');\n\n  content += `const content = {\\n${formattedDictionaryMap}\\n};\\n`;\n\n  if (format === 'esm') content += `export default content;\\n`;\n  if (format === 'cjs') content += `module.exports = content;\\n`;\n\n  return content;\n};\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 writeFetchDictionary = async (\n  dynamicDictionaries: LocalizedDictionaryOutput,\n  configuration = getConfiguration(),\n  formats: ('cjs' | 'esm')[] = ['cjs', 'esm']\n): Promise<LocalizedDictionaryOutput> => {\n  const { fetchDictionariesDir } = configuration.content;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(fetchDictionariesDir), { recursive: true });\n\n  const resultDictionariesPaths: LocalizedDictionaryOutput = {};\n\n  // Write entry points for each dictionary in parallel\n  await parallelize(\n    Object.entries(dynamicDictionaries),\n    async ([key, localedDictionariesPathsRecord]) => {\n      if (key === 'undefined') return;\n\n      await parallelize(formats, async (format) => {\n        const extension = format === 'cjs' ? 'cjs' : 'mjs';\n        const content = generateDictionaryEntryPoint(\n          localedDictionariesPathsRecord,\n          format,\n          configuration\n        );\n\n        await writeFileIfChanged(\n          resolve(fetchDictionariesDir, `${key}.${extension}`),\n          content\n        ).catch((err) => {\n          console.error(\n            `Error creating fetch ${colorizePath(resolve(fetchDictionariesDir, `${key}.${extension}`))}:`,\n            err\n          );\n        });\n      });\n    }\n  );\n\n  return resultDictionariesPaths;\n};\n"],"mappings":";;;;;;;;;;;AAiBA,MAAa,gCACX,gCACA,SAAwB,OACxB,wDAAkC,KACvB;CACX,MAAM,EAAE,yBAAyB,cAAc;CAC/C,MAAM,EAAE,gBAAgB,cAAc;CAEtC,IAAI,UAAU;CAEd,MAAMA,yBAAiC,OAAO,QAC5C,+BACD,CACE,KAAK,CAAC,QAAQ,gBAAgB;EAC7B,MAAM,2EACK,sBAAsB,WAAW,eAAe,CAC1D;AAED,MAAI,WAAW,MACb,QAAO,MAAM,OAAO,mDAAmD,YAAY,gBAAgB,WAAW,WAAW,IAAI,GAAG,OAAO,qEAAqE,aAAa;AAG3N,SAAO,MAAM,OAAO,mDAAmD,YAAY,gBAAgB,WAAW,WAAW,IAAI,GAAG,OAAO,gFAAgF,aAAa;GACpO,CACD,KAAK,MAAM;AAEd,YAAW,sBAAsB,uBAAuB;AAExD,KAAI,WAAW,MAAO,YAAW;AACjC,KAAI,WAAW,MAAO,YAAW;AAEjC,QAAO;;;;;;;;;;;;;;;;;;AAmBT,MAAa,uBAAuB,OAClC,qBACA,wDAAkC,EAClC,UAA6B,CAAC,OAAO,MAAM,KACJ;CACvC,MAAM,EAAE,yBAAyB,cAAc;AAG/C,0DAAoB,qBAAqB,EAAE,EAAE,WAAW,MAAM,CAAC;CAE/D,MAAMC,0BAAqD,EAAE;AAG7D,OAAMC,sCACJ,OAAO,QAAQ,oBAAoB,EACnC,OAAO,CAAC,KAAK,oCAAoC;AAC/C,MAAI,QAAQ,YAAa;AAEzB,QAAMA,sCAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;GAC7C,MAAM,UAAU,6BACd,gCACA,QACA,cACD;AAED,SAAMC,qEACI,sBAAsB,GAAG,IAAI,GAAG,YAAY,EACpD,QACD,CAAC,OAAO,QAAQ;AACf,YAAQ,MACN,kFAA6C,sBAAsB,GAAG,IAAI,GAAG,YAAY,CAAC,CAAC,IAC3F,IACD;KACD;IACF;GAEL;AAED,QAAO"}

package/dist/cjs/buildIntlayerDictionary/writeMergedDictionary.cjs

@@ -2,9 +2,9 @@ const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 const require_utils_parallelize = require('../utils/parallelize.cjs');
 const require_writeJsonIfChanged = require('../writeJsonIfChanged.cjs');
 let node_fs_promises = require("node:fs/promises");
-let __intlayer_config = require("@intlayer/config");
+let _intlayer_config = require("@intlayer/config");
 let node_path = require("node:path");
-let __intlayer_core = require("@intlayer/core");
+let _intlayer_core = require("@intlayer/core");
 
 //#region src/buildIntlayerDictionary/writeMergedDictionary.ts
 /**
@@ -23,15 +23,15 @@ let __intlayer_core = require("@intlayer/core");
 * // { key: 'home', content: { ... } },
 * ```
 */
-const writeMergedDictionaries = async (groupedDictionaries, configuration = (0, __intlayer_config.getConfiguration)()) => {
+const writeMergedDictionaries = async (groupedDictionaries, configuration = (0, _intlayer_config.getConfiguration)()) => {
 	const { dictionariesDir } = configuration.content;
 	await (0, node_fs_promises.mkdir)((0, node_path.resolve)(dictionariesDir), { recursive: true });
 	const results = await require_utils_parallelize.parallelize(Object.entries(groupedDictionaries), async ([key, dictionariesEntry]) => {
 		if (key === "undefined") return;
-		const mergedDictionary = (0, __intlayer_core.mergeDictionaries)((0, __intlayer_core.normalizeDictionaries)(dictionariesEntry.dictionaries, configuration));
+		const mergedDictionary = (0, _intlayer_core.mergeDictionaries)((0, _intlayer_core.normalizeDictionaries)(dictionariesEntry.dictionaries, configuration));
 		const resultFilePath = (0, node_path.resolve)(dictionariesDir, `${key}.json`);
 		await require_writeJsonIfChanged.writeJsonIfChanged(resultFilePath, mergedDictionary).catch((err) => {
-			console.error(`Error creating merged ${(0, __intlayer_config.colorizePath)(resultFilePath)}:`, err);
+			console.error(`Error creating merged ${(0, _intlayer_config.colorizePath)(resultFilePath)}:`, err);
 		});
 		return [key, {
 			dictionaryPath: resultFilePath,

package/dist/cjs/buildIntlayerDictionary/writeMergedDictionary.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"writeMergedDictionary.cjs","names":["parallelize","writeJsonIfChanged"],"sources":["../../../src/buildIntlayerDictionary/writeMergedDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { colorizePath, getConfiguration } from '@intlayer/config';\nimport { mergeDictionaries, normalizeDictionaries } from '@intlayer/core';\nimport type { Dictionary } from '@intlayer/types';\nimport { parallelize } from '../utils/parallelize';\nimport { writeJsonIfChanged } from '../writeJsonIfChanged';\nimport type { UnmergedDictionaryOutput } from './writeUnmergedDictionary';\n\nexport type MergedDictionaryResult = {\n  dictionaryPath: string;\n  dictionary: Dictionary;\n};\n\nexport type MergedDictionaryOutput = Record<string, MergedDictionaryResult>;\n\n/**\n * Write the merged dictionaries to the dictionariesDir\n * @param groupedDictionaries - The grouped dictionaries\n * @param configuration - The configuration\n * @returns The merged 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/dictionary/home.json\n * // { key: 'home', content: { ... } },\n * ```\n */\nexport const writeMergedDictionaries = async (\n  groupedDictionaries: UnmergedDictionaryOutput,\n  configuration = getConfiguration()\n): Promise<MergedDictionaryOutput> => {\n  const { dictionariesDir } = configuration.content;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(dictionariesDir), { recursive: true });\n\n  const results = await parallelize(\n    Object.entries(groupedDictionaries),\n    async ([key, dictionariesEntry]) => {\n      if (key === 'undefined') {\n        return undefined as unknown as readonly [\n          string,\n          MergedDictionaryResult,\n        ];\n      }\n\n      const normalizedDictionaries = normalizeDictionaries(\n        dictionariesEntry.dictionaries,\n        configuration\n      );\n\n      const mergedDictionary = mergeDictionaries(normalizedDictionaries);\n\n      const outputFileName = `${key}.json`;\n      const resultFilePath = resolve(dictionariesDir, outputFileName);\n\n      // Write the merged dictionary\n      await writeJsonIfChanged(resultFilePath, mergedDictionary).catch(\n        (err) => {\n          console.error(\n            `Error creating merged ${colorizePath(resultFilePath)}:`,\n            err\n          );\n        }\n      );\n\n      return [\n        key,\n        {\n          dictionaryPath: resultFilePath,\n          dictionary: mergedDictionary,\n        } as MergedDictionaryResult,\n      ] as const;\n    }\n  );\n\n  return Object.fromEntries(\n    results.filter(Boolean) as Array<readonly [string, MergedDictionaryResult]>\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,MAAa,0BAA0B,OACrC,qBACA,yDAAkC,KACE;CACpC,MAAM,EAAE,oBAAoB,cAAc;AAG1C,0DAAoB,gBAAgB,EAAE,EAAE,WAAW,MAAM,CAAC;CAE1D,MAAM,UAAU,MAAMA,sCACpB,OAAO,QAAQ,oBAAoB,EACnC,OAAO,CAAC,KAAK,uBAAuB;AAClC,MAAI,QAAQ,YACV;EAWF,MAAM,qGAJJ,kBAAkB,cAClB,cACD,CAEiE;EAGlE,MAAM,wCAAyB,iBADR,GAAG,IAAI,OACiC;AAG/D,QAAMC,8CAAmB,gBAAgB,iBAAiB,CAAC,OACxD,QAAQ;AACP,WAAQ,MACN,6DAAsC,eAAe,CAAC,IACtD,IACD;IAEJ;AAED,SAAO,CACL,KACA;GACE,gBAAgB;GAChB,YAAY;GACb,CACF;GAEJ;AAED,QAAO,OAAO,YACZ,QAAQ,OAAO,QAAQ,CACxB"}
+{"version":3,"file":"writeMergedDictionary.cjs","names":["parallelize","writeJsonIfChanged"],"sources":["../../../src/buildIntlayerDictionary/writeMergedDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { colorizePath, getConfiguration } from '@intlayer/config';\nimport { mergeDictionaries, normalizeDictionaries } from '@intlayer/core';\nimport type { Dictionary } from '@intlayer/types';\nimport { parallelize } from '../utils/parallelize';\nimport { writeJsonIfChanged } from '../writeJsonIfChanged';\nimport type { UnmergedDictionaryOutput } from './writeUnmergedDictionary';\n\nexport type MergedDictionaryResult = {\n  dictionaryPath: string;\n  dictionary: Dictionary;\n};\n\nexport type MergedDictionaryOutput = Record<string, MergedDictionaryResult>;\n\n/**\n * Write the merged dictionaries to the dictionariesDir\n * @param groupedDictionaries - The grouped dictionaries\n * @param configuration - The configuration\n * @returns The merged 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/dictionary/home.json\n * // { key: 'home', content: { ... } },\n * ```\n */\nexport const writeMergedDictionaries = async (\n  groupedDictionaries: UnmergedDictionaryOutput,\n  configuration = getConfiguration()\n): Promise<MergedDictionaryOutput> => {\n  const { dictionariesDir } = configuration.content;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(dictionariesDir), { recursive: true });\n\n  const results = await parallelize(\n    Object.entries(groupedDictionaries),\n    async ([key, dictionariesEntry]) => {\n      if (key === 'undefined') {\n        return undefined as unknown as readonly [\n          string,\n          MergedDictionaryResult,\n        ];\n      }\n\n      const normalizedDictionaries = normalizeDictionaries(\n        dictionariesEntry.dictionaries,\n        configuration\n      );\n\n      const mergedDictionary = mergeDictionaries(normalizedDictionaries);\n\n      const outputFileName = `${key}.json`;\n      const resultFilePath = resolve(dictionariesDir, outputFileName);\n\n      // Write the merged dictionary\n      await writeJsonIfChanged(resultFilePath, mergedDictionary).catch(\n        (err) => {\n          console.error(\n            `Error creating merged ${colorizePath(resultFilePath)}:`,\n            err\n          );\n        }\n      );\n\n      return [\n        key,\n        {\n          dictionaryPath: resultFilePath,\n          dictionary: mergedDictionary,\n        } as MergedDictionaryResult,\n      ] as const;\n    }\n  );\n\n  return Object.fromEntries(\n    results.filter(Boolean) as Array<readonly [string, MergedDictionaryResult]>\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,MAAa,0BAA0B,OACrC,qBACA,wDAAkC,KACE;CACpC,MAAM,EAAE,oBAAoB,cAAc;AAG1C,0DAAoB,gBAAgB,EAAE,EAAE,WAAW,MAAM,CAAC;CAE1D,MAAM,UAAU,MAAMA,sCACpB,OAAO,QAAQ,oBAAoB,EACnC,OAAO,CAAC,KAAK,uBAAuB;AAClC,MAAI,QAAQ,YACV;EAWF,MAAM,mGAJJ,kBAAkB,cAClB,cACD,CAEiE;EAGlE,MAAM,wCAAyB,iBADR,GAAG,IAAI,OACiC;AAG/D,QAAMC,8CAAmB,gBAAgB,iBAAiB,CAAC,OACxD,QAAQ;AACP,WAAQ,MACN,4DAAsC,eAAe,CAAC,IACtD,IACD;IAEJ;AAED,SAAO,CACL,KACA;GACE,gBAAgB;GAChB,YAAY;GACb,CACF;GAEJ;AAED,QAAO,OAAO,YACZ,QAAQ,OAAO,QAAQ,CACxB"}

package/dist/cjs/buildIntlayerDictionary/writeRemoteDictionary.cjs

@@ -5,9 +5,9 @@ const require_writeJsonIfChanged = require('../writeJsonIfChanged.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 __intlayer_config = require("@intlayer/config");
+let _intlayer_config = require("@intlayer/config");
 let node_path = require("node:path");
-let __intlayer_core = require("@intlayer/core");
+let _intlayer_core = require("@intlayer/core");
 
 //#region src/buildIntlayerDictionary/writeRemoteDictionary.ts
 /**
@@ -26,16 +26,16 @@ let __intlayer_core = require("@intlayer/core");
 * // { key: 'home', content: { ... } },
 * ```
 */
-const writeRemoteDictionary = async (remoteDictionaries, configuration = (0, __intlayer_config.getConfiguration)()) => {
+const writeRemoteDictionary = async (remoteDictionaries, configuration = (0, _intlayer_config.getConfiguration)()) => {
 	const { remoteDictionariesDir } = configuration.content;
 	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.orderDictionaries)(require_loadDictionaries_loadRemoteDictionaries.formatDistantDictionaries(dictionaries), configuration);
+		const orderedDictionaries = (0, _intlayer_core.orderDictionaries)(require_loadDictionaries_loadRemoteDictionaries.formatDistantDictionaries(dictionaries), configuration);
 		const unmergedFilePath = (0, node_path.resolve)(remoteDictionariesDir, `${key}.json`);
 		await require_writeJsonIfChanged.writeJsonIfChanged(unmergedFilePath, orderedDictionaries).catch((err) => {
-			console.error(`${__intlayer_config.x} Error creating unmerged ${(0, __intlayer_config.colorizePath)(unmergedFilePath)}:`, err);
+			console.error(`${_intlayer_config.x} Error creating unmerged ${(0, _intlayer_config.colorizePath)(unmergedFilePath)}:`, err);
 		});
 		return [key, {
 			dictionaryPath: unmergedFilePath,

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

@@ -1 +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, getConfiguration, x } from '@intlayer/config';\nimport { orderDictionaries } from '@intlayer/core';\nimport type { Dictionary } from '@intlayer/types';\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 = getConfiguration()\n): Promise<RemoteDictionaryOutput> => {\n  const { remoteDictionariesDir } = configuration.content;\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(\n        formattedDictionaries,\n        configuration\n      );\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,wBAAwB,OACnC,oBACA,yDAAkC,KACE;CACpC,MAAM,EAAE,0BAA0B,cAAc;AAGhD,0DAAoB,sBAAsB,EAAE,EAAE,WAAW,MAAM,CAAC;CAQhE,MAAM,sBAAsBA,+EANCC,4DAC3B,oBACA,cACD,CAGuE;CAGxE,MAAM,UAAU,MAAMC,sCACpB,OAAO,QAAQ,oBAAoB,EACnC,OAAO,CAAC,KAAK,kBAAkB;AAC7B,MAAI,QAAQ,YACV;EAQF,MAAM,6DAFwBC,0EAA0B,aAAa,EAInE,cACD;EAGD,MAAM,0CAA2B,uBADV,GAAG,IAAI,OACyC;AAGvE,QAAMC,8CAAmB,kBAAkB,oBAAoB,CAAC,OAC7D,QAAQ;AACP,WAAQ,MACN,GAAGC,oBAAE,+DAAwC,iBAAiB,CAAC,IAC/D,IACD;IAEJ;AAED,SAAO,CACL,KACA;GACE,gBAAgB;GAChB;GACD,CACF;GAEJ;AAED,QAAO,OAAO,YACZ,QAAQ,OAAO,QAAQ,CAGxB"}
+{"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, getConfiguration, x } from '@intlayer/config';\nimport { orderDictionaries } from '@intlayer/core';\nimport type { Dictionary } from '@intlayer/types';\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 = getConfiguration()\n): Promise<RemoteDictionaryOutput> => {\n  const { remoteDictionariesDir } = configuration.content;\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(\n        formattedDictionaries,\n        configuration\n      );\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,wBAAwB,OACnC,oBACA,wDAAkC,KACE;CACpC,MAAM,EAAE,0BAA0B,cAAc;AAGhD,0DAAoB,sBAAsB,EAAE,EAAE,WAAW,MAAM,CAAC;CAQhE,MAAM,sBAAsBA,+EANCC,4DAC3B,oBACA,cACD,CAGuE;CAGxE,MAAM,UAAU,MAAMC,sCACpB,OAAO,QAAQ,oBAAoB,EACnC,OAAO,CAAC,KAAK,kBAAkB;AAC7B,MAAI,QAAQ,YACV;EAQF,MAAM,4DAFwBC,0EAA0B,aAAa,EAInE,cACD;EAGD,MAAM,0CAA2B,uBADV,GAAG,IAAI,OACyC;AAGvE,QAAMC,8CAAmB,kBAAkB,oBAAoB,CAAC,OAC7D,QAAQ;AACP,WAAQ,MACN,GAAGC,mBAAE,8DAAwC,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

@@ -3,9 +3,9 @@ const require_utils_parallelize = require('../utils/parallelize.cjs');
 const require_filterInvalidDictionaries = require('../filterInvalidDictionaries.cjs');
 const require_writeJsonIfChanged = require('../writeJsonIfChanged.cjs');
 let node_fs_promises = require("node:fs/promises");
-let __intlayer_config = require("@intlayer/config");
+let _intlayer_config = require("@intlayer/config");
 let node_path = require("node:path");
-let __intlayer_core = require("@intlayer/core");
+let _intlayer_core = require("@intlayer/core");
 
 //#region src/buildIntlayerDictionary/writeUnmergedDictionary.ts
 const groupDictionariesByKey = (dictionaries) => dictionaries.reduce((acc, dictionary) => {
@@ -40,10 +40,10 @@ const writeUnmergedDictionaries = async (dictionaries, configuration) => {
 	const groupedDictionaries = groupDictionariesByKey(require_filterInvalidDictionaries.filterInvalidDictionaries(dictionaries, configuration));
 	const results = await require_utils_parallelize.parallelize(Object.entries(groupedDictionaries), async ([key, dictionaries$1]) => {
 		if (key === "undefined") return;
-		const orderedDictionaries = (0, __intlayer_core.orderDictionaries)(dictionaries$1, configuration);
+		const orderedDictionaries = (0, _intlayer_core.orderDictionaries)(dictionaries$1, configuration);
 		const unmergedFilePath = (0, node_path.resolve)(unmergedDictionariesDir, `${key}.json`);
 		await require_writeJsonIfChanged.writeJsonIfChanged(unmergedFilePath, orderedDictionaries).catch((err) => {
-			console.error(`${__intlayer_config.x} Error creating unmerged ${(0, __intlayer_config.colorizePath)(unmergedFilePath)}:`, err);
+			console.error(`${_intlayer_config.x} Error creating unmerged ${(0, _intlayer_config.colorizePath)(unmergedFilePath)}:`, err);
 		});
 		return [key, {
 			dictionaryPath: unmergedFilePath,

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

@@ -1 +1 @@
-{"version":3,"file":"writeUnmergedDictionary.cjs","names":["filterInvalidDictionaries","parallelize","dictionaries","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';\nimport { orderDictionaries } from '@intlayer/core';\nimport type { Dictionary, IntlayerConfig } from '@intlayer/types';\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<string, UnmergedDictionaryResult>;\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): Promise<UnmergedDictionaryOutput> => {\n  const { unmergedDictionariesDir } = configuration.content;\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  );\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(\n        dictionaries,\n        configuration\n      );\n\n      const outputFileName = `${key}.json`;\n      const unmergedFilePath = resolve(unmergedDictionariesDir, 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: 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":";;;;;;;;;;AASA,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;;;;;;;;;;;;;;;;;;;;;AA6BH,MAAa,4BAA4B,OACvC,cACA,kBACsC;CACtC,MAAM,EAAE,4BAA4B,cAAc;AAGlD,0DAAoB,wBAAwB,EAAE,EAAE,WAAW,MAAM,CAAC;CAQlE,MAAM,sBAAsB,uBANCA,4DAC3B,cACA,cACD,CAGuE;CAExE,MAAM,UAAU,MAAMC,sCACpB,OAAO,QAAQ,oBAAoB,EACnC,OAAO,CAAC,KAAKC,oBAAkB;AAC7B,MAAI,QAAQ,YACV;EAMF,MAAM,6DACJA,gBACA,cACD;EAGD,MAAM,0CAA2B,yBADV,GAAG,IAAI,OAC2C;AAGzE,QAAMC,8CAAmB,kBAAkB,oBAAoB,CAAC,OAC7D,QAAQ;AACP,WAAQ,MACN,GAAGC,oBAAE,+DAAwC,iBAAiB,CAAC,IAC/D,IACD;IAEJ;AAED,SAAO,CACL,KACA;GACE,gBAAgB;GAChB,cAAcF;GACf,CACF;GAEJ;AAED,QAAO,OAAO,YACZ,QAAQ,OAAO,QAAQ,CAGxB"}
+{"version":3,"file":"writeUnmergedDictionary.cjs","names":["filterInvalidDictionaries","parallelize","dictionaries","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';\nimport { orderDictionaries } from '@intlayer/core';\nimport type { Dictionary, IntlayerConfig } from '@intlayer/types';\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<string, UnmergedDictionaryResult>;\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): Promise<UnmergedDictionaryOutput> => {\n  const { unmergedDictionariesDir } = configuration.content;\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  );\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(\n        dictionaries,\n        configuration\n      );\n\n      const outputFileName = `${key}.json`;\n      const unmergedFilePath = resolve(unmergedDictionariesDir, 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: 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":";;;;;;;;;;AASA,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;;;;;;;;;;;;;;;;;;;;;AA6BH,MAAa,4BAA4B,OACvC,cACA,kBACsC;CACtC,MAAM,EAAE,4BAA4B,cAAc;AAGlD,0DAAoB,wBAAwB,EAAE,EAAE,WAAW,MAAM,CAAC;CAQlE,MAAM,sBAAsB,uBANCA,4DAC3B,cACA,cACD,CAGuE;CAExE,MAAM,UAAU,MAAMC,sCACpB,OAAO,QAAQ,oBAAoB,EACnC,OAAO,CAAC,KAAKC,oBAAkB;AAC7B,MAAI,QAAQ,YACV;EAMF,MAAM,4DACJA,gBACA,cACD;EAGD,MAAM,0CAA2B,yBADV,GAAG,IAAI,OAC2C;AAGzE,QAAMC,8CAAmB,kBAAkB,oBAAoB,CAAC,OAC7D,QAAQ;AACP,WAAQ,MACN,GAAGC,mBAAE,8DAAwC,iBAAiB,CAAC,IAC/D,IACD;IAEJ;AAED,SAAO,CACL,KACA;GACE,gBAAgB;GAChB,cAAcF;GACf,CACF;GAEJ;AAED,QAAO,OAAO,YACZ,QAAQ,OAAO,QAAQ,CAGxB"}

package/dist/cjs/cleanOutputDir.cjs

@@ -1,12 +1,12 @@
 const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
 let node_fs = require("node:fs");
 let node_fs_promises = require("node:fs/promises");
-let __intlayer_config_client = require("@intlayer/config/client");
+let _intlayer_config_client = require("@intlayer/config/client");
 
 //#region src/cleanOutputDir.ts
 const cleanOutputDir = async (configuration) => {
 	const { dictionariesDir, unmergedDictionariesDir, dynamicDictionariesDir, remoteDictionariesDir, fetchDictionariesDir, mainDir, typesDir, configDir, cacheDir } = configuration.content;
-	const appLogger = (0, __intlayer_config_client.getAppLogger)(configuration);
+	const appLogger = (0, _intlayer_config_client.getAppLogger)(configuration);
 	const directoriesToClean = [
 		dictionariesDir,
 		unmergedDictionariesDir,

package/dist/cjs/cleanOutputDir.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"cleanOutputDir.cjs","names":["directoriesToClean: string[]"],"sources":["../../src/cleanOutputDir.ts"],"sourcesContent":["import { existsSync } from 'node:fs';\nimport { rm } from 'node:fs/promises';\nimport { getAppLogger } from '@intlayer/config/client';\nimport type { IntlayerConfig } from '@intlayer/types';\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.content;\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,uDAAyB,cAAc;CAE7C,MAAMA,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"}
+{"version":3,"file":"cleanOutputDir.cjs","names":["directoriesToClean: string[]"],"sources":["../../src/cleanOutputDir.ts"],"sourcesContent":["import { existsSync } from 'node:fs';\nimport { rm } from 'node:fs/promises';\nimport { getAppLogger } from '@intlayer/config/client';\nimport type { IntlayerConfig } from '@intlayer/types';\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.content;\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,MAAMA,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/createDictionaryEntryPoint/createDictionaryEntryPoint.cjs

@@ -8,12 +8,12 @@ const require_createDictionaryEntryPoint_getBuiltFetchDictionariesPath = require
 const require_createDictionaryEntryPoint_getBuiltRemoteDictionariesPath = require('./getBuiltRemoteDictionariesPath.cjs');
 const require_createDictionaryEntryPoint_getBuiltUnmergedDictionariesPath = require('./getBuiltUnmergedDictionariesPath.cjs');
 let node_fs_promises = require("node:fs/promises");
-let __intlayer_config = require("@intlayer/config");
+let _intlayer_config = require("@intlayer/config");
 let node_path = require("node:path");
 
 //#region src/createDictionaryEntryPoint/createDictionaryEntryPoint.ts
-const writeDictionaryFiles = async (paths, fileName, functionName, format, configuration = (0, __intlayer_config.getConfiguration)()) => {
-	const content = require_createDictionaryEntryPoint_generateDictionaryListContent.generateDictionaryListContent(await paths, functionName, format, configuration);
+const writeDictionaryFiles = async (paths, fileName, importType, functionName, format, configuration = (0, _intlayer_config.getConfiguration)()) => {
+	const content = require_createDictionaryEntryPoint_generateDictionaryListContent.generateDictionaryListContent(await paths, functionName, importType, format, configuration);
 	const extension = format === "cjs" ? "cjs" : "mjs";
 	const { mainDir } = configuration.content;
 	await require_writeFileIfChanged.writeFileIfChanged((0, node_path.resolve)(mainDir, `${fileName}.${extension}`), content);
@@ -21,42 +21,47 @@ const writeDictionaryFiles = async (paths, fileName, functionName, format, confi
 /**
 * This function generates a list of dictionaries in the main directory
 */
-const createDictionaryEntryPoint = async (configuration = (0, __intlayer_config.getConfiguration)(), formats) => {
+const createDictionaryEntryPoint = async (configuration = (0, _intlayer_config.getConfiguration)(), formats) => {
 	const outputFormats = formats ?? configuration.build.outputFormat;
 	const { mainDir } = configuration.content;
 	await (0, node_fs_promises.mkdir)(mainDir, { recursive: true });
 	await require_utils_parallelize.parallelize([
-		...outputFormats.map((format) => ({
-			paths: require_createDictionaryEntryPoint_getBuiltRemoteDictionariesPath.getBuiltRemoteDictionariesPath(configuration),
-			functionName: "getRemoteDictionaries",
-			fileName: "remote_dictionaries",
-			format
-		})),
 		...outputFormats.map((format) => ({
 			paths: require_createDictionaryEntryPoint_getBuiltDictionariesPath.getBuiltDictionariesPath(configuration),
+			importType: "json",
 			functionName: "getDictionaries",
 			fileName: "dictionaries",
 			format
 		})),
 		...outputFormats.map((format) => ({
 			paths: require_createDictionaryEntryPoint_getBuiltUnmergedDictionariesPath.getBuiltUnmergedDictionariesPath(configuration),
+			importType: "json",
 			functionName: "getUnmergedDictionaries",
 			fileName: "unmerged_dictionaries",
 			format
 		})),
 		...outputFormats.map((format) => ({
 			paths: require_createDictionaryEntryPoint_getBuiltDynamicDictionariesPath.getBuiltDynamicDictionariesPath(configuration, format),
+			importType: "javascript",
 			functionName: "getDynamicDictionaries",
 			fileName: "dynamic_dictionaries",
 			format
 		})),
 		...outputFormats.map((format) => ({
 			paths: require_createDictionaryEntryPoint_getBuiltFetchDictionariesPath.getBuiltFetchDictionariesPath(configuration, format),
+			importType: "javascript",
 			functionName: "getFetchDictionaries",
 			fileName: "fetch_dictionaries",
 			format
+		})),
+		...outputFormats.map((format) => ({
+			paths: require_createDictionaryEntryPoint_getBuiltRemoteDictionariesPath.getBuiltRemoteDictionariesPath(configuration),
+			importType: "json",
+			functionName: "getRemoteDictionaries",
+			fileName: "remote_dictionaries",
+			format
 		}))
-	], async ({ paths, fileName, format, functionName }) => writeDictionaryFiles(paths, fileName, functionName, format, configuration));
+	], async ({ paths, fileName, format, functionName, importType }) => writeDictionaryFiles(paths, fileName, importType, functionName, format, configuration));
 };
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"createDictionaryEntryPoint.cjs","names":["generateDictionaryListContent","writeFileIfChanged","parallelize","getBuiltRemoteDictionariesPath","getBuiltDictionariesPath","getBuiltUnmergedDictionariesPath","getBuiltDynamicDictionariesPath","getBuiltFetchDictionariesPath"],"sources":["../../../src/createDictionaryEntryPoint/createDictionaryEntryPoint.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { getConfiguration } from '@intlayer/config';\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  functionName: string,\n  format: 'cjs' | 'esm',\n  configuration = getConfiguration()\n) => {\n  const content = generateDictionaryListContent(\n    await paths,\n    functionName,\n    format,\n    configuration\n  );\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n\n  const { mainDir } = configuration.content;\n\n  await writeFileIfChanged(\n    resolve(mainDir, `${fileName}.${extension}`),\n    content\n  );\n};\n\n/**\n * This function generates a list of dictionaries in the main directory\n */\nexport const createDictionaryEntryPoint = async (\n  configuration = getConfiguration(),\n  formats?: ('cjs' | 'esm')[]\n) => {\n  const outputFormats = formats ?? configuration.build.outputFormat;\n  const { mainDir } = configuration.content;\n\n  await mkdir(mainDir, { recursive: true });\n\n  const writeOperations = [\n    ...outputFormats.map((format) => ({\n      paths: getBuiltRemoteDictionariesPath(configuration),\n      functionName: 'getRemoteDictionaries',\n      fileName: 'remote_dictionaries' as const,\n      format,\n    })),\n    ...outputFormats.map((format) => ({\n      paths: getBuiltDictionariesPath(configuration),\n      functionName: 'getDictionaries',\n      fileName: 'dictionaries' as const,\n      format,\n    })),\n    ...outputFormats.map((format) => ({\n      paths: getBuiltUnmergedDictionariesPath(configuration),\n      functionName: 'getUnmergedDictionaries',\n      fileName: 'unmerged_dictionaries' as const,\n      format,\n    })),\n    ...outputFormats.map((format) => ({\n      paths: getBuiltDynamicDictionariesPath(configuration, format),\n      functionName: 'getDynamicDictionaries',\n      fileName: 'dynamic_dictionaries' as const,\n      format,\n    })),\n    ...outputFormats.map((format) => ({\n      paths: getBuiltFetchDictionariesPath(configuration, format),\n      functionName: 'getFetchDictionaries',\n      fileName: 'fetch_dictionaries' as const,\n      format,\n    })),\n  ];\n\n  await parallelize(\n    writeOperations,\n    async ({ paths, fileName, format, functionName }) =>\n      writeDictionaryFiles(paths, fileName, functionName, format, configuration)\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;AAYA,MAAM,uBAAuB,OAC3B,OACA,UACA,cACA,QACA,yDAAkC,KAC/B;CACH,MAAM,UAAUA,+FACd,MAAM,OACN,cACA,QACA,cACD;CACD,MAAM,YAAY,WAAW,QAAQ,QAAQ;CAE7C,MAAM,EAAE,YAAY,cAAc;AAElC,OAAMC,qEACI,SAAS,GAAG,SAAS,GAAG,YAAY,EAC5C,QACD;;;;;AAMH,MAAa,6BAA6B,OACxC,yDAAkC,EAClC,YACG;CACH,MAAM,gBAAgB,WAAW,cAAc,MAAM;CACrD,MAAM,EAAE,YAAY,cAAc;AAElC,mCAAY,SAAS,EAAE,WAAW,MAAM,CAAC;AAmCzC,OAAMC,sCAjCkB;EACtB,GAAG,cAAc,KAAK,YAAY;GAChC,OAAOC,iGAA+B,cAAc;GACpD,cAAc;GACd,UAAU;GACV;GACD,EAAE;EACH,GAAG,cAAc,KAAK,YAAY;GAChC,OAAOC,qFAAyB,cAAc;GAC9C,cAAc;GACd,UAAU;GACV;GACD,EAAE;EACH,GAAG,cAAc,KAAK,YAAY;GAChC,OAAOC,qGAAiC,cAAc;GACtD,cAAc;GACd,UAAU;GACV;GACD,EAAE;EACH,GAAG,cAAc,KAAK,YAAY;GAChC,OAAOC,mGAAgC,eAAe,OAAO;GAC7D,cAAc;GACd,UAAU;GACV;GACD,EAAE;EACH,GAAG,cAAc,KAAK,YAAY;GAChC,OAAOC,+FAA8B,eAAe,OAAO;GAC3D,cAAc;GACd,UAAU;GACV;GACD,EAAE;EACJ,EAIC,OAAO,EAAE,OAAO,UAAU,QAAQ,mBAChC,qBAAqB,OAAO,UAAU,cAAc,QAAQ,cAAc,CAC7E"}
+{"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';\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 content = generateDictionaryListContent(\n    await paths,\n    functionName,\n    importType,\n    format,\n    configuration\n  );\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n\n  const { mainDir } = configuration.content;\n\n  await writeFileIfChanged(\n    resolve(mainDir, `${fileName}.${extension}`),\n    content\n  );\n};\n\n/**\n * This function generates a list of dictionaries in the main directory\n */\nexport const createDictionaryEntryPoint = async (\n  configuration = getConfiguration(),\n  formats?: ('cjs' | 'esm')[]\n) => {\n  const outputFormats = formats ?? configuration.build.outputFormat;\n  const { mainDir } = configuration.content;\n\n  await mkdir(mainDir, { recursive: true });\n\n  const writeOperations = [\n    ...outputFormats.map(\n      (format) =>\n        ({\n          paths: getBuiltDictionariesPath(configuration),\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),\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(configuration, format),\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(configuration, format),\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),\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      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,wDAAkC,KAC/B;CACH,MAAM,UAAUA,+FACd,MAAM,OACN,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;;;;;AAMH,MAAa,6BAA6B,OACxC,wDAAkC,EAClC,YACG;CACH,MAAM,gBAAgB,WAAW,cAAc,MAAM;CACrD,MAAM,EAAE,YAAY,cAAc;AAElC,mCAAY,SAAS,EAAE,WAAW,MAAM,CAAC;AAuDzC,OAAMC,sCArDkB;EACtB,GAAG,cAAc,KACd,YACE;GACC,OAAOC,qFAAyB,cAAc;GAC9C,YAAY;GACZ,cAAc;GACd,UAAU;GACV;GACD,EACJ;EACD,GAAG,cAAc,KACd,YACE;GACC,OAAOC,qGAAiC,cAAc;GACtD,YAAY;GACZ,cAAc;GACd,UAAU;GACV;GACD,EACJ;EACD,GAAG,cAAc,KACd,YACE;GACC,OAAOC,mGAAgC,eAAe,OAAO;GAC7D,YAAY;GACZ,cAAc;GACd,UAAU;GACV;GACD,EACJ;EACD,GAAG,cAAc,KACd,YACE;GACC,OAAOC,+FAA8B,eAAe,OAAO;GAC3D,YAAY;GACZ,cAAc;GACd,UAAU;GACV;GACD,EACJ;EACD,GAAG,cAAc,KACd,YACE;GACC,OAAOC,iGAA+B,cAAc;GACpD,YAAY;GACZ,cAAc;GACd,UAAU;GACV;GACD,EACJ;EACF,EAIC,OAAO,EAAE,OAAO,UAAU,QAAQ,cAAc,iBAC9C,qBACE,OACA,UACA,YACA,cACA,QACA,cACD,CACJ"}

package/dist/cjs/createDictionaryEntryPoint/generateDictionaryListContent.cjs

@@ -1,22 +1,22 @@
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 const require_utils_getFileHash = require('../utils/getFileHash.cjs');
-let __intlayer_config = require("@intlayer/config");
+let _intlayer_config = require("@intlayer/config");
 let node_path = require("node:path");
 
 //#region src/createDictionaryEntryPoint/generateDictionaryListContent.ts
 /**
 * This function generates the content of the dictionary list file
 */
-const generateDictionaryListContent = (dictionaries, functionName, format = "esm", configuration = (0, __intlayer_config.getConfiguration)()) => {
+const generateDictionaryListContent = (dictionaries, functionName, importType, format = "esm", configuration = (0, _intlayer_config.getConfiguration)()) => {
 	const { mainDir } = configuration.content;
 	let content = "";
 	const dictionariesRef = dictionaries.map((dictionaryPath) => ({
-		relativePath: (0, __intlayer_config.normalizePath)((0, node_path.relative)(mainDir, dictionaryPath)),
+		relativePath: (0, _intlayer_config.normalizePath)((0, node_path.relative)(mainDir, dictionaryPath)),
 		id: (0, node_path.basename)(dictionaryPath, (0, node_path.extname)(dictionaryPath)),
 		hash: `_${require_utils_getFileHash.getFileHash(dictionaryPath)}`
 	}));
 	dictionariesRef.forEach((dictionary) => {
-		if (format === "esm") content += `import ${dictionary.hash} from '${dictionary.relativePath}' with { type: 'json' };\n`;
+		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";

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

@@ -1 +1 @@
-{"version":3,"file":"generateDictionaryListContent.cjs","names":["getFileHash","formattedDictionaryMap: string"],"sources":["../../../src/createDictionaryEntryPoint/generateDictionaryListContent.ts"],"sourcesContent":["import { basename, extname, relative } from 'node:path';\nimport { getConfiguration, normalizePath } from '@intlayer/config';\nimport { getFileHash } from '../utils/getFileHash';\n\n/**\n * This function generates the content of the dictionary list file\n */\nexport const generateDictionaryListContent = (\n  dictionaries: string[],\n  functionName: string,\n  format: 'cjs' | 'esm' = 'esm',\n  configuration = getConfiguration()\n): string => {\n  const { mainDir } = configuration.content;\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: `_${getFileHash(dictionaryPath)}`, // Get the hash of the dictionary to avoid conflicts\n  }));\n\n  // Import all dictionaries\n  dictionariesRef.forEach((dictionary) => {\n    if (format === 'esm')\n      content += `import ${dictionary.hash} from '${dictionary.relativePath}' 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":";;;;;;;;;AAOA,MAAa,iCACX,cACA,cACA,SAAwB,OACxB,yDAAkC,KACvB;CACX,MAAM,EAAE,YAAY,cAAc;CAElC,IAAI,UAAU;CAEd,MAAM,kBAAkB,aAAa,KAAK,oBAAoB;EAC5D,2EAAqC,SAAS,eAAe,CAAC;EAC9D,4BAAa,uCAAwB,eAAe,CAAC;EACrD,MAAM,IAAIA,sCAAY,eAAe;EACtC,EAAE;AAGH,iBAAgB,SAAS,eAAe;AACtC,MAAI,WAAW,MACb,YAAW,UAAU,WAAW,KAAK,SAAS,WAAW,aAAa;AACxE,MAAI,WAAW,MACb,YAAW,SAAS,WAAW,KAAK,cAAc,WAAW,aAAa;GAC5E;AAEF,YAAW;CAGX,MAAMC,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"}
+{"version":3,"file":"generateDictionaryListContent.cjs","names":["getFileHash","formattedDictionaryMap: string"],"sources":["../../../src/createDictionaryEntryPoint/generateDictionaryListContent.ts"],"sourcesContent":["import { basename, extname, relative } from 'node:path';\nimport { getConfiguration, normalizePath } from '@intlayer/config';\nimport { getFileHash } from '../utils/getFileHash';\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.content;\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: `_${getFileHash(dictionaryPath)}`, // Get the hash of the dictionary to avoid conflicts\n  }));\n\n  // Import all dictionaries\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":";;;;;;;;;AAOA,MAAa,iCACX,cACA,cACA,YACA,SAAwB,OACxB,wDAAkC,KACvB;CACX,MAAM,EAAE,YAAY,cAAc;CAElC,IAAI,UAAU;CAEd,MAAM,kBAAkB,aAAa,KAAK,oBAAoB;EAC5D,0EAAqC,SAAS,eAAe,CAAC;EAC9D,4BAAa,uCAAwB,eAAe,CAAC;EACrD,MAAM,IAAIA,sCAAY,eAAe;EACtC,EAAE;AAGH,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,MAAMC,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

@@ -1,6 +1,6 @@
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 let node_fs = require("node:fs");
-let __intlayer_config = require("@intlayer/config");
+let _intlayer_config = require("@intlayer/config");
 let fast_glob = require("fast-glob");
 fast_glob = require_rolldown_runtime.__toESM(fast_glob);
 
@@ -11,7 +11,7 @@ fast_glob = require_rolldown_runtime.__toESM(fast_glob);
 const getBuiltDictionariesPath = async (configuration) => {
 	const { dictionariesDir, mainDir } = configuration.content;
 	if (!(0, node_fs.existsSync)(mainDir)) (0, node_fs.mkdirSync)(mainDir, { recursive: true });
-	return await (0, fast_glob.default)(`${(0, __intlayer_config.normalizePath)(dictionariesDir)}/**/*.json`);
+	return await (0, fast_glob.default)(`${(0, _intlayer_config.normalizePath)(dictionariesDir)}/**/*.json`);
 };
 
 //#endregion