@intlayer/chokidar 8.7.0 → 8.7.1-canary-0

package/dist/cjs/buildIntlayerDictionary/writeDynamicDictionary.cjs

@@ -11,38 +11,13 @@ let _intlayer_core_plugins = require("@intlayer/core/plugins");
 
 //#region src/buildIntlayerDictionary/writeDynamicDictionary.ts
 const DICTIONARIES_SUBDIR = "json";
-const LOAD_CONTENT_MODULE = "_loadjson";
-/**
-* Assembles the entry point file content from a pre-built preamble (import/require line),
-* the locale→path record, the dictionary key, and the output format.
-* Shared by all dictionary entry point generators.
-*/
-const buildEntryPointContent = (preamble, localizedDictionariesPathsRecord, key, format = "esm") => {
-	const formattedDictionaryMap = Object.keys(localizedDictionariesPathsRecord).sort((a, b) => String(a).localeCompare(String(b))).map((locale) => `  '${locale}': () => loadContent('${key}', '${locale}')`).join(",\n");
-	let content = preamble;
-	content += `const content = {\n${formattedDictionaryMap}\n};\n\n`;
-	if (format === "esm") content += `export default content;\n`;
-	if (format === "cjs") content += `module.exports = content;\n`;
-	return content;
-};
-/**
-* Generates the content of the shared `loadContent` module written once per
-* output directory. Locales are baked in so each dynamic import has only one
-* variable (`key`), making it statically analyzable by Vite/Rollup.
-*/
-const generateDynamicLoadContentModule = (format, locales) => {
-	const body = `const loadContent = (key) => ({\n${[...locales].sort((a, b) => String(a).localeCompare(String(b))).map((locale) => format === "esm" ? `  '${locale}': () => import(\`./${DICTIONARIES_SUBDIR}/\${key}/${locale}.json\`).then(m => m.default)` : `  '${locale}': () => Promise.resolve(require(\`./${DICTIONARIES_SUBDIR}/\${key}/${locale}.json\`))`).join(",\n")}\n});\n`;
-	if (format === "esm") return `${body}\nexport { loadContent };\n`;
-	return `${body}\nmodule.exports = { loadContent };\n`;
-};
 /**
 * Generates the content of a dictionary entry point file.
-* `loadContent` is imported from the shared module and called with the key.
 */
-const generateDictionaryEntryPoint = (key, format = "esm") => {
-	const extension = format === "cjs" ? "cjs" : "mjs";
-	if (format === "esm") return `import { loadContent } from './${LOAD_CONTENT_MODULE}.${extension}';\n\nconst content = loadContent('${key}');\n\nexport default content;\n`;
-	return `const { loadContent } = require('./${LOAD_CONTENT_MODULE}.${extension}');\n\nmodule.exports = loadContent('${key}');\n`;
+const generateDictionaryEntryPoint = (key, locales, format = "esm") => {
+	const localeEntries = [...locales].sort((a, b) => String(a).localeCompare(String(b))).map((locale) => format === "esm" ? `  '${locale}': () => import('./${DICTIONARIES_SUBDIR}/${key}/${locale}.json').then(m => m.default)` : `  '${locale}': () => Promise.resolve(require('./${DICTIONARIES_SUBDIR}/${key}/${locale}.json'))`).join(",\n");
+	if (format === "esm") return `const content = {\n${localeEntries}\n};\n\nexport default content;\n`;
+	return `module.exports = {\n${localeEntries}\n};\n`;
 };
 /**
 * Write the localized dictionaries to the dictionariesDir
@@ -65,12 +40,6 @@ const writeDynamicDictionary = async (mergedDictionaries, configuration, formats
 	const { dynamicDictionariesDir } = configuration.system;
 	const dictDir = (0, node_path.resolve)(dynamicDictionariesDir, DICTIONARIES_SUBDIR);
 	await (0, node_fs_promises.mkdir)(dictDir, { recursive: true });
-	await require_utils_parallelize.parallelize(formats, async (format) => {
-		const extension = format === "cjs" ? "cjs" : "mjs";
-		await require_writeFileIfChanged.writeFileIfChanged((0, node_path.resolve)(dynamicDictionariesDir, `${LOAD_CONTENT_MODULE}.${extension}`), generateDynamicLoadContentModule(format, locales)).catch((err) => {
-			console.error(`Error creating dynamic ${(0, _intlayer_config_logger.colorizePath)((0, node_path.resolve)(dynamicDictionariesDir, `${LOAD_CONTENT_MODULE}.${extension}`))}:`, err);
-		});
-	});
 	const resultDictionariesPaths = {};
 	await require_utils_parallelize.parallelize(Object.entries(mergedDictionaries).sort(([a], [b]) => String(a).localeCompare(String(b))), async ([key, dictionaryEntry]) => {
 		if (key === "undefined") return;
@@ -91,7 +60,7 @@ const writeDynamicDictionary = async (mergedDictionaries, configuration, formats
 		resultDictionariesPaths[key] = localizedDictionariesPathsRecord;
 		await require_utils_parallelize.parallelize(formats, async (format) => {
 			const extension = format === "cjs" ? "cjs" : "mjs";
-			const content = generateDictionaryEntryPoint(key, format);
+			const content = generateDictionaryEntryPoint(key, locales, format);
 			await require_writeFileIfChanged.writeFileIfChanged((0, node_path.resolve)(dynamicDictionariesDir, `${key}.${extension}`), content).catch((err) => {
 				console.error(`Error creating dynamic ${(0, _intlayer_config_logger.colorizePath)((0, node_path.resolve)(dynamicDictionariesDir, `${key}.${extension}`))}:`, err);
 			});
@@ -101,8 +70,6 @@ const writeDynamicDictionary = async (mergedDictionaries, configuration, formats
 };
 
 //#endregion
-exports.buildEntryPointContent = buildEntryPointContent;
 exports.generateDictionaryEntryPoint = generateDictionaryEntryPoint;
-exports.generateDynamicLoadContentModule = generateDynamicLoadContentModule;
 exports.writeDynamicDictionary = writeDynamicDictionary;
 //# sourceMappingURL=writeDynamicDictionary.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"writeDynamicDictionary.cjs","names":["OUTPUT_FORMAT","parallelize","writeFileIfChanged","writeJsonIfChanged"],"sources":["../../../src/buildIntlayerDictionary/writeDynamicDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { OUTPUT_FORMAT } from '@intlayer/config/defaultValues';\nimport { colorizePath } from '@intlayer/config/logger';\nimport { getPerLocaleDictionary } from '@intlayer/core/plugins';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\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\nconst DICTIONARIES_SUBDIR = 'json'; // Necessary to add a static first dir for Turbopack\nconst LOAD_CONTENT_MODULE = '_loadjson';\n\n/**\n * Assembles the entry point file content from a pre-built preamble (import/require line),\n * the locale→path record, the dictionary key, and the output format.\n * Shared by all dictionary entry point generators.\n */\nexport const buildEntryPointContent = (\n  preamble: string,\n  localizedDictionariesPathsRecord: LocalizedDictionaryResult,\n  key: string,\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  const formattedDictionaryMap: string = Object.keys(\n    localizedDictionariesPathsRecord\n  )\n    .sort((a, b) => String(a).localeCompare(String(b)))\n    .map((locale) => `  '${locale}': () => loadContent('${key}', '${locale}')`)\n    .join(',\\n');\n\n  let content = preamble;\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 * Generates the content of the shared `loadContent` module written once per\n * output directory. Locales are baked in so each dynamic import has only one\n * variable (`key`), making it statically analyzable by Vite/Rollup.\n */\nexport const generateDynamicLoadContentModule = (\n  format: 'cjs' | 'esm',\n  locales: string[]\n): string => {\n  const sortedLocales = [...locales].sort((a, b) =>\n    String(a).localeCompare(String(b))\n  );\n\n  const localeEntries = sortedLocales\n    .map((locale) =>\n      format === 'esm'\n        ? `  '${locale}': () => import(\\`./${DICTIONARIES_SUBDIR}/\\${key}/${locale}.json\\`).then(m => m.default)`\n        : `  '${locale}': () => Promise.resolve(require(\\`./${DICTIONARIES_SUBDIR}/\\${key}/${locale}.json\\`))`\n    )\n    .join(',\\n');\n\n  const body = `const loadContent = (key) => ({\\n${localeEntries}\\n});\\n`;\n\n  if (format === 'esm') return `${body}\\nexport { loadContent };\\n`;\n  return `${body}\\nmodule.exports = { loadContent };\\n`;\n};\n\n/**\n * Generates the content of a dictionary entry point file.\n * `loadContent` is imported from the shared module and called with the key.\n */\nexport const generateDictionaryEntryPoint = (\n  key: string,\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n  if (format === 'esm') {\n    return (\n      `import { loadContent } from './${LOAD_CONTENT_MODULE}.${extension}';\\n\\n` +\n      `const content = loadContent('${key}');\\n\\n` +\n      `export default content;\\n`\n    );\n  }\n  return (\n    `const { loadContent } = require('./${LOAD_CONTENT_MODULE}.${extension}');\\n\\n` +\n    `module.exports = loadContent('${key}');\\n`\n  );\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_dictionary/dictionaries/en_home.json\n * // .intlayer/dynamic_dictionary/dictionaries/fr_home.json\n * ```\n */\nexport const writeDynamicDictionary = async (\n  mergedDictionaries: MergedDictionaryOutput,\n  configuration: IntlayerConfig,\n  formats: ('cjs' | 'esm')[] = OUTPUT_FORMAT\n): Promise<LocalizedDictionaryOutput> => {\n  const { locales, defaultLocale } = configuration.internationalization;\n  const { dynamicDictionariesDir } = configuration.system;\n\n  const dictDir = resolve(dynamicDictionariesDir, DICTIONARIES_SUBDIR);\n  await mkdir(dictDir, { recursive: true });\n  await parallelize(formats, async (format) => {\n    const extension = format === 'cjs' ? 'cjs' : 'mjs';\n    await writeFileIfChanged(\n      resolve(dynamicDictionariesDir, `${LOAD_CONTENT_MODULE}.${extension}`),\n      generateDynamicLoadContentModule(format, locales)\n    ).catch((err) => {\n      console.error(\n        `Error creating dynamic ${colorizePath(resolve(dynamicDictionariesDir, `${LOAD_CONTENT_MODULE}.${extension}`))}:`,\n        err\n      );\n    });\n  });\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      const keyDir = resolve(dictDir, key);\n      await mkdir(keyDir, { recursive: true });\n\n      await parallelize(locales, async (locale) => {\n        const localizedDictionary = getPerLocaleDictionary(\n          dictionaryEntry.dictionary,\n          locale,\n          defaultLocale\n        );\n\n        // Directory structure: json/key/locale.json\n        const resultFilePath = resolve(keyDir, `${locale}.json`);\n\n        await writeJsonIfChanged(resultFilePath, localizedDictionary).catch(\n          (err) => {\n            console.error(\n              `Error creating localized ${key}/${locale}.json:`,\n              err\n            );\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(key, format);\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":";;;;;;;;;;;;AA2BA,MAAM,sBAAsB;AAC5B,MAAM,sBAAsB;;;;;;AAO5B,MAAa,0BACX,UACA,kCACA,KACA,SAAwB,UACb;CACX,MAAM,yBAAiC,OAAO,KAC5C,iCACD,CACE,MAAM,GAAG,MAAM,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CAAC,CAClD,KAAK,WAAW,MAAM,OAAO,wBAAwB,IAAI,MAAM,OAAO,IAAI,CAC1E,KAAK,MAAM;CAEd,IAAI,UAAU;AACd,YAAW,sBAAsB,uBAAuB;AACxD,KAAI,WAAW,MAAO,YAAW;AACjC,KAAI,WAAW,MAAO,YAAW;AAEjC,QAAO;;;;;;;AAQT,MAAa,oCACX,QACA,YACW;CAaX,MAAM,OAAO,oCAZS,CAAC,GAAG,QAAQ,CAAC,MAAM,GAAG,MAC1C,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CACnC,CAGE,KAAK,WACJ,WAAW,QACP,MAAM,OAAO,sBAAsB,oBAAoB,WAAW,OAAO,iCACzE,MAAM,OAAO,uCAAuC,oBAAoB,WAAW,OAAO,WAC/F,CACA,KAAK,MAAM,CAEiD;AAE/D,KAAI,WAAW,MAAO,QAAO,GAAG,KAAK;AACrC,QAAO,GAAG,KAAK;;;;;;AAOjB,MAAa,gCACX,KACA,SAAwB,UACb;CACX,MAAM,YAAY,WAAW,QAAQ,QAAQ;AAC7C,KAAI,WAAW,MACb,QACE,kCAAkC,oBAAoB,GAAG,UAAU,qCACnC,IAAI;AAIxC,QACE,sCAAsC,oBAAoB,GAAG,UAAU,uCACtC,IAAI;;;;;;;;;;;;;;;;;;AAoBzC,MAAa,yBAAyB,OACpC,oBACA,eACA,UAA6BA,iDACU;CACvC,MAAM,EAAE,SAAS,kBAAkB,cAAc;CACjD,MAAM,EAAE,2BAA2B,cAAc;CAEjD,MAAM,iCAAkB,wBAAwB,oBAAoB;AACpE,mCAAY,SAAS,EAAE,WAAW,MAAM,CAAC;AACzC,OAAMC,sCAAY,SAAS,OAAO,WAAW;EAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;AAC7C,QAAMC,qEACI,wBAAwB,GAAG,oBAAoB,GAAG,YAAY,EACtE,iCAAiC,QAAQ,QAAQ,CAClD,CAAC,OAAO,QAAQ;AACf,WAAQ,MACN,2FAA+C,wBAAwB,GAAG,oBAAoB,GAAG,YAAY,CAAC,CAAC,IAC/G,IACD;IACD;GACF;CAEF,MAAM,0BAAqD,EAAE;AAG7D,OAAMD,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,MAAM,mCAA8D,EAAE;EAEtE,MAAM,gCAAiB,SAAS,IAAI;AACpC,oCAAY,QAAQ,EAAE,WAAW,MAAM,CAAC;AAExC,QAAMA,sCAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,yEACJ,gBAAgB,YAChB,QACA,cACD;GAGD,MAAM,wCAAyB,QAAQ,GAAG,OAAO,OAAO;AAExD,SAAME,8CAAmB,gBAAgB,oBAAoB,CAAC,OAC3D,QAAQ;AACP,YAAQ,MACN,4BAA4B,IAAI,GAAG,OAAO,SAC1C,IACD;KAEJ;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,6BAA6B,KAAK,OAAO;AAEzD,SAAMC,qEACI,wBAAwB,GAAG,IAAI,GAAG,YAAY,EACtD,QACD,CAAC,OAAO,QAAQ;AACf,YAAQ,MACN,2FAA+C,wBAAwB,GAAG,IAAI,GAAG,YAAY,CAAC,CAAC,IAC/F,IACD;KACD;IACF;GAEL;AAED,QAAO"}
+{"version":3,"file":"writeDynamicDictionary.cjs","names":["OUTPUT_FORMAT","parallelize","writeJsonIfChanged","writeFileIfChanged"],"sources":["../../../src/buildIntlayerDictionary/writeDynamicDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { OUTPUT_FORMAT } from '@intlayer/config/defaultValues';\nimport { colorizePath } from '@intlayer/config/logger';\nimport { getPerLocaleDictionary } from '@intlayer/core/plugins';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\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\nconst DICTIONARIES_SUBDIR = 'json'; // Necessary to add a static first dir for Turbopack\n\n/**\n * Generates the content of a dictionary entry point file.\n */\nexport const generateDictionaryEntryPoint = (\n  key: string,\n  locales: string[],\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  const sortedLocales = [...locales].sort((a, b) =>\n    String(a).localeCompare(String(b))\n  );\n\n  const localeEntries = sortedLocales\n    .map((locale) =>\n      format === 'esm'\n        ? `  '${locale}': () => import('./${DICTIONARIES_SUBDIR}/${key}/${locale}.json').then(m => m.default)`\n        : `  '${locale}': () => Promise.resolve(require('./${DICTIONARIES_SUBDIR}/${key}/${locale}.json'))`\n    )\n    .join(',\\n');\n\n  if (format === 'esm') {\n    return (\n      `const content = {\\n${localeEntries}\\n};\\n\\n` +\n      `export default content;\\n`\n    );\n  }\n  return `module.exports = {\\n${localeEntries}\\n};\\n`;\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_dictionary/dictionaries/en_home.json\n * // .intlayer/dynamic_dictionary/dictionaries/fr_home.json\n * ```\n */\nexport const writeDynamicDictionary = async (\n  mergedDictionaries: MergedDictionaryOutput,\n  configuration: IntlayerConfig,\n  formats: ('cjs' | 'esm')[] = OUTPUT_FORMAT\n): Promise<LocalizedDictionaryOutput> => {\n  const { locales, defaultLocale } = configuration.internationalization;\n  const { dynamicDictionariesDir } = configuration.system;\n\n  const dictDir = resolve(dynamicDictionariesDir, DICTIONARIES_SUBDIR);\n  await mkdir(dictDir, { 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      const keyDir = resolve(dictDir, key);\n      await mkdir(keyDir, { recursive: true });\n\n      await parallelize(locales, async (locale) => {\n        const localizedDictionary = getPerLocaleDictionary(\n          dictionaryEntry.dictionary,\n          locale,\n          defaultLocale\n        );\n\n        // Directory structure: json/key/locale.json\n        const resultFilePath = resolve(keyDir, `${locale}.json`);\n\n        await writeJsonIfChanged(resultFilePath, localizedDictionary).catch(\n          (err) => {\n            console.error(\n              `Error creating localized ${key}/${locale}.json:`,\n              err\n            );\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(key, locales, format);\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":";;;;;;;;;;;;AA2BA,MAAM,sBAAsB;;;;AAK5B,MAAa,gCACX,KACA,SACA,SAAwB,UACb;CAKX,MAAM,gBAJgB,CAAC,GAAG,QAAQ,CAAC,MAAM,GAAG,MAC1C,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CACnC,CAGE,KAAK,WACJ,WAAW,QACP,MAAM,OAAO,qBAAqB,oBAAoB,GAAG,IAAI,GAAG,OAAO,gCACvE,MAAM,OAAO,sCAAsC,oBAAoB,GAAG,IAAI,GAAG,OAAO,UAC7F,CACA,KAAK,MAAM;AAEd,KAAI,WAAW,MACb,QACE,sBAAsB,cAAc;AAIxC,QAAO,uBAAuB,cAAc;;;;;;;;;;;;;;;;;;AAmB9C,MAAa,yBAAyB,OACpC,oBACA,eACA,UAA6BA,iDACU;CACvC,MAAM,EAAE,SAAS,kBAAkB,cAAc;CACjD,MAAM,EAAE,2BAA2B,cAAc;CAEjD,MAAM,iCAAkB,wBAAwB,oBAAoB;AACpE,mCAAY,SAAS,EAAE,WAAW,MAAM,CAAC;CAEzC,MAAM,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,MAAM,mCAA8D,EAAE;EAEtE,MAAM,gCAAiB,SAAS,IAAI;AACpC,oCAAY,QAAQ,EAAE,WAAW,MAAM,CAAC;AAExC,QAAMA,sCAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,yEACJ,gBAAgB,YAChB,QACA,cACD;GAGD,MAAM,wCAAyB,QAAQ,GAAG,OAAO,OAAO;AAExD,SAAMC,8CAAmB,gBAAgB,oBAAoB,CAAC,OAC3D,QAAQ;AACP,YAAQ,MACN,4BAA4B,IAAI,GAAG,OAAO,SAC1C,IACD;KAEJ;AAED,oCAAiC,UAAU;IACzC,gBAAgB;IAChB,YAAY;IACb;IACD;AAEF,0BAAwB,OAAO;AAE/B,QAAMD,sCAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;GAC7C,MAAM,UAAU,6BAA6B,KAAK,SAAS,OAAO;AAElE,SAAME,qEACI,wBAAwB,GAAG,IAAI,GAAG,YAAY,EACtD,QACD,CAAC,OAAO,QAAQ;AACf,YAAQ,MACN,2FAA+C,wBAAwB,GAAG,IAAI,GAAG,YAAY,CAAC,CAAC,IAC/F,IACD;KACD;IACF;GAEL;AAED,QAAO"}

package/dist/cjs/buildIntlayerDictionary/writeFetchDictionary.cjs

@@ -9,29 +9,11 @@ let _intlayer_config_utils = require("@intlayer/config/utils");
 let _intlayer_config_defaultValues = require("@intlayer/config/defaultValues");
 
 //#region src/buildIntlayerDictionary/writeFetchDictionary.ts
-const LOAD_CONTENT_MODULE = "_loadjson";
-/**
-* Generates the content of the shared `loadContent` module for fetch dictionaries.
-* - `configuration` is imported at runtime from "intlayer" (liveSyncURL not baked in).
-* - Fallback delegates to the dynamic dictionary's `_loadjson` module.
-* - Locales are baked in so each entry is a static function referencing one locale.
-*/
-const generateFetchLoadContentModule = (format, relativePrefix, locales) => {
-	const sortedLocales = [...locales].sort((a, b) => String(a).localeCompare(String(b)));
-	const extension = format === "cjs" ? "cjs" : "mjs";
-	const body = `const loadContent = (key) => {
-  const dynContent = loadContentDyn(key);
-  return {\n${sortedLocales.map((locale) => `  '${locale}': async () => {\n    try {\n      const res = await fetch(\`\${editor.liveSyncURL}/dictionaries/\${key}/${locale}\`);\n      return await res.json();\n    } catch {\n      return dynContent['${locale}']();\n    }\n  }`).join(",\n")}\n  };\n};\n`;
-	if (format === "esm") return `import { editor } from 'intlayer';\nimport { loadContent as loadContentDyn } from '${relativePrefix}/${LOAD_CONTENT_MODULE}.${extension}';\n\n${body}\nexport { loadContent };\n`;
-	return `const { editor } = require('intlayer');\nconst { loadContent: loadContentDyn } = require('${relativePrefix}/${LOAD_CONTENT_MODULE}.${extension}');\n\n${body}\nmodule.exports = { loadContent };\n`;
-};
-/**
-* Generates the content of a fetch dictionary entry point file.
-*/
-const generateDictionaryEntryPoint = (key, format = "esm") => {
+const generateDictionaryEntryPoint = (key, locales, relativePrefix, format = "esm") => {
 	const extension = format === "cjs" ? "cjs" : "mjs";
-	if (format === "esm") return `import { loadContent } from './${LOAD_CONTENT_MODULE}.${extension}';\n\nconst content = loadContent('${key}');\n\nexport default content;\n`;
-	return `const { loadContent } = require('./${LOAD_CONTENT_MODULE}.${extension}');\n\nmodule.exports = loadContent('${key}');\n`;
+	const localeEntries = locales.sort((a, b) => String(a).localeCompare(String(b))).map((locale) => `  '${locale}': async () => {\n    try {\n      const res = await fetch(\`\${editor.liveSyncURL}/dictionaries/${key}/${locale}\`);\n      return await res.json();\n    } catch {\n      return dynContent['${locale}']();\n    }\n  }`).join(",\n");
+	if (format === "esm") return `import { editor } from 'intlayer';\nimport dynContent from '${relativePrefix}/${key}.${extension}';\n\nconst content = {\n${localeEntries}\n};\n\nexport default content;\n`;
+	return `const { editor } = require('intlayer');\nconst dynContent = require('${relativePrefix}/${key}.${extension}');\n\nmodule.exports = {\n${localeEntries}\n};\n`;
 };
 /**
 * Write the localized dictionaries to the dictionariesDir
@@ -55,18 +37,12 @@ const writeFetchDictionary = async (dynamicDictionaries, configuration, formats
 	let relativePrefix = (0, _intlayer_config_utils.normalizePath)((0, node_path.relative)(fetchDictionariesDir, dynamicDictionariesDir));
 	if (!relativePrefix.startsWith(".")) relativePrefix = `./${relativePrefix}`;
 	await (0, node_fs_promises.mkdir)((0, node_path.resolve)(fetchDictionariesDir), { recursive: true });
-	await require_utils_parallelize.parallelize(formats, async (format) => {
-		const extension = format === "cjs" ? "cjs" : "mjs";
-		await require_writeFileIfChanged.writeFileIfChanged((0, node_path.resolve)(fetchDictionariesDir, `${LOAD_CONTENT_MODULE}.${extension}`), generateFetchLoadContentModule(format, relativePrefix, locales)).catch((err) => {
-			console.error(`Error creating fetch ${(0, _intlayer_config_logger.colorizePath)((0, node_path.resolve)(fetchDictionariesDir, `${LOAD_CONTENT_MODULE}.${extension}`))}:`, err);
-		});
-	});
 	const resultDictionariesPaths = {};
 	await require_utils_parallelize.parallelize(Object.entries(dynamicDictionaries), async ([key]) => {
 		if (key === "undefined") return;
 		await require_utils_parallelize.parallelize(formats, async (format) => {
 			const extension = format === "cjs" ? "cjs" : "mjs";
-			const content = generateDictionaryEntryPoint(key, format);
+			const content = generateDictionaryEntryPoint(key, locales, relativePrefix, format);
 			await require_writeFileIfChanged.writeFileIfChanged((0, node_path.resolve)(fetchDictionariesDir, `${key}.${extension}`), content).catch((err) => {
 				console.error(`Error creating fetch ${(0, _intlayer_config_logger.colorizePath)((0, node_path.resolve)(fetchDictionariesDir, `${key}.${extension}`))}:`, err);
 			});
@@ -77,6 +53,5 @@ const writeFetchDictionary = async (dynamicDictionaries, configuration, formats
 
 //#endregion
 exports.generateDictionaryEntryPoint = generateDictionaryEntryPoint;
-exports.generateFetchLoadContentModule = generateFetchLoadContentModule;
 exports.writeFetchDictionary = writeFetchDictionary;
 //# sourceMappingURL=writeFetchDictionary.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"writeFetchDictionary.cjs","names":["OUTPUT_FORMAT","parallelize","writeFileIfChanged"],"sources":["../../../src/buildIntlayerDictionary/writeFetchDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { relative, resolve } from 'node:path';\nimport { OUTPUT_FORMAT } from '@intlayer/config/defaultValues';\nimport { colorizePath } from '@intlayer/config/logger';\nimport { normalizePath } from '@intlayer/config/utils';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport { parallelize } from '../utils/parallelize';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\nimport type { LocalizedDictionaryOutput } from './writeDynamicDictionary';\n\nconst LOAD_CONTENT_MODULE = '_loadjson';\n\n/**\n * Generates the content of the shared `loadContent` module for fetch dictionaries.\n * - `configuration` is imported at runtime from \"intlayer\" (liveSyncURL not baked in).\n * - Fallback delegates to the dynamic dictionary's `_loadjson` module.\n * - Locales are baked in so each entry is a static function referencing one locale.\n */\nexport const generateFetchLoadContentModule = (\n  format: 'cjs' | 'esm',\n  relativePrefix: string,\n  locales: string[]\n): string => {\n  const sortedLocales = [...locales].sort((a, b) =>\n    String(a).localeCompare(String(b))\n  );\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n\n  const localeEntries = sortedLocales\n    .map(\n      (locale) =>\n        `  '${locale}': async () => {\\n` +\n        `    try {\\n` +\n        `      const res = await fetch(\\`\\${editor.liveSyncURL}/dictionaries/\\${key}/${locale}\\`);\\n` +\n        `      return await res.json();\\n` +\n        `    } catch {\\n` +\n        `      return dynContent['${locale}']();\\n` +\n        `    }\\n` +\n        `  }`\n    )\n    .join(',\\n');\n\n  const body =\n    `const loadContent = (key) => {\\n` +\n    `  const dynContent = loadContentDyn(key);\\n` +\n    `  return {\\n${localeEntries}\\n  };\\n` +\n    `};\\n`;\n\n  if (format === 'esm') {\n    return (\n      `import { editor } from 'intlayer';\\n` +\n      `import { loadContent as loadContentDyn } from '${relativePrefix}/${LOAD_CONTENT_MODULE}.${extension}';\\n\\n` +\n      `${body}\\nexport { loadContent };\\n`\n    );\n  }\n  return (\n    `const { editor } = require('intlayer');\\n` +\n    `const { loadContent: loadContentDyn } = require('${relativePrefix}/${LOAD_CONTENT_MODULE}.${extension}');\\n\\n` +\n    `${body}\\nmodule.exports = { loadContent };\\n`\n  );\n};\n\n/**\n * Generates the content of a fetch dictionary entry point file.\n */\nexport const generateDictionaryEntryPoint = (\n  key: string,\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n  if (format === 'esm') {\n    return (\n      `import { loadContent } from './${LOAD_CONTENT_MODULE}.${extension}';\\n\\n` +\n      `const content = loadContent('${key}');\\n\\n` +\n      `export default content;\\n`\n    );\n  }\n  return (\n    `const { loadContent } = require('./${LOAD_CONTENT_MODULE}.${extension}');\\n\\n` +\n    `module.exports = loadContent('${key}');\\n`\n  );\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_dictionary/home.mjs\n * // .intlayer/fetch_dictionary/home.cjs\n * ```\n */\nexport const writeFetchDictionary = async (\n  dynamicDictionaries: LocalizedDictionaryOutput,\n  configuration: IntlayerConfig,\n  formats: ('cjs' | 'esm')[] = OUTPUT_FORMAT\n): Promise<LocalizedDictionaryOutput> => {\n  const { fetchDictionariesDir, dynamicDictionariesDir } = configuration.system;\n  const { locales } = configuration.internationalization;\n\n  // Compute relative path from fetch dir (where _loadjson lives) to dynamic dir\n  let relativePrefix = normalizePath(\n    relative(fetchDictionariesDir, dynamicDictionariesDir)\n  );\n  if (!relativePrefix.startsWith('.')) {\n    relativePrefix = `./${relativePrefix}`;\n  }\n\n  await mkdir(resolve(fetchDictionariesDir), { recursive: true });\n\n  // Write the shared loadContent module once per format\n  await parallelize(formats, async (format) => {\n    const extension = format === 'cjs' ? 'cjs' : 'mjs';\n    await writeFileIfChanged(\n      resolve(fetchDictionariesDir, `${LOAD_CONTENT_MODULE}.${extension}`),\n      generateFetchLoadContentModule(format, relativePrefix, locales)\n    ).catch((err) => {\n      console.error(\n        `Error creating fetch ${colorizePath(resolve(fetchDictionariesDir, `${LOAD_CONTENT_MODULE}.${extension}`))}:`,\n        err\n      );\n    });\n  });\n\n  const resultDictionariesPaths: LocalizedDictionaryOutput = {};\n\n  // Write entry points for each dictionary in parallel\n  await parallelize(Object.entries(dynamicDictionaries), async ([key]) => {\n    if (key === 'undefined') return;\n\n    await parallelize(formats, async (format) => {\n      const extension = format === 'cjs' ? 'cjs' : 'mjs';\n      const content = generateDictionaryEntryPoint(key, format);\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  return resultDictionariesPaths;\n};\n"],"mappings":";;;;;;;;;;;AAUA,MAAM,sBAAsB;;;;;;;AAQ5B,MAAa,kCACX,QACA,gBACA,YACW;CACX,MAAM,gBAAgB,CAAC,GAAG,QAAQ,CAAC,MAAM,GAAG,MAC1C,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CACnC;CACD,MAAM,YAAY,WAAW,QAAQ,QAAQ;CAgB7C,MAAM,OACJ;;cAfoB,cACnB,KACE,WACC,MAAM,OAAO,2GAEkE,OAAO,gFAG1D,OAAO,mBAGtC,CACA,KAAK,MAAM,CAKiB;AAG/B,KAAI,WAAW,MACb,QACE,sFACkD,eAAe,GAAG,oBAAoB,GAAG,UAAU,QAClG,KAAK;AAGZ,QACE,6FACoD,eAAe,GAAG,oBAAoB,GAAG,UAAU,SACpG,KAAK;;;;;AAOZ,MAAa,gCACX,KACA,SAAwB,UACb;CACX,MAAM,YAAY,WAAW,QAAQ,QAAQ;AAC7C,KAAI,WAAW,MACb,QACE,kCAAkC,oBAAoB,GAAG,UAAU,qCACnC,IAAI;AAIxC,QACE,sCAAsC,oBAAoB,GAAG,UAAU,uCACtC,IAAI;;;;;;;;;;;;;;;;;;AAoBzC,MAAa,uBAAuB,OAClC,qBACA,eACA,UAA6BA,iDACU;CACvC,MAAM,EAAE,sBAAsB,2BAA2B,cAAc;CACvE,MAAM,EAAE,YAAY,cAAc;CAGlC,IAAI,mFACO,sBAAsB,uBAAuB,CACvD;AACD,KAAI,CAAC,eAAe,WAAW,IAAI,CACjC,kBAAiB,KAAK;AAGxB,0DAAoB,qBAAqB,EAAE,EAAE,WAAW,MAAM,CAAC;AAG/D,OAAMC,sCAAY,SAAS,OAAO,WAAW;EAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;AAC7C,QAAMC,qEACI,sBAAsB,GAAG,oBAAoB,GAAG,YAAY,EACpE,+BAA+B,QAAQ,gBAAgB,QAAQ,CAChE,CAAC,OAAO,QAAQ;AACf,WAAQ,MACN,yFAA6C,sBAAsB,GAAG,oBAAoB,GAAG,YAAY,CAAC,CAAC,IAC3G,IACD;IACD;GACF;CAEF,MAAM,0BAAqD,EAAE;AAG7D,OAAMD,sCAAY,OAAO,QAAQ,oBAAoB,EAAE,OAAO,CAAC,SAAS;AACtE,MAAI,QAAQ,YAAa;AAEzB,QAAMA,sCAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;GAC7C,MAAM,UAAU,6BAA6B,KAAK,OAAO;AAEzD,SAAMC,qEACI,sBAAsB,GAAG,IAAI,GAAG,YAAY,EACpD,QACD,CAAC,OAAO,QAAQ;AACf,YAAQ,MACN,yFAA6C,sBAAsB,GAAG,IAAI,GAAG,YAAY,CAAC,CAAC,IAC3F,IACD;KACD;IACF;GACF;AAEF,QAAO"}
+{"version":3,"file":"writeFetchDictionary.cjs","names":["OUTPUT_FORMAT","parallelize","writeFileIfChanged"],"sources":["../../../src/buildIntlayerDictionary/writeFetchDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { relative, resolve } from 'node:path';\nimport { OUTPUT_FORMAT } from '@intlayer/config/defaultValues';\nimport { colorizePath } from '@intlayer/config/logger';\nimport { normalizePath } from '@intlayer/config/utils';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport { parallelize } from '../utils/parallelize';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\nimport type { LocalizedDictionaryOutput } from './writeDynamicDictionary';\n\nexport const generateDictionaryEntryPoint = (\n  key: string,\n  locales: string[],\n  relativePrefix: string,\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n\n  const localeEntries = locales\n    .sort((a, b) => String(a).localeCompare(String(b)))\n    .map(\n      (locale) =>\n        `  '${locale}': async () => {\\n` +\n        `    try {\\n` +\n        `      const res = await fetch(\\`\\${editor.liveSyncURL}/dictionaries/${key}/${locale}\\`);\\n` +\n        `      return await res.json();\\n` +\n        `    } catch {\\n` +\n        `      return dynContent['${locale}']();\\n` +\n        `    }\\n` +\n        `  }`\n    )\n    .join(',\\n');\n\n  if (format === 'esm') {\n    return (\n      `import { editor } from 'intlayer';\\n` +\n      `import dynContent from '${relativePrefix}/${key}.${extension}';\\n\\n` +\n      `const content = {\\n${localeEntries}\\n};\\n\\n` +\n      `export default content;\\n`\n    );\n  }\n  return (\n    `const { editor } = require('intlayer');\\n` +\n    `const dynContent = require('${relativePrefix}/${key}.${extension}');\\n\\n` +\n    `module.exports = {\\n${localeEntries}\\n};\\n`\n  );\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_dictionary/home.mjs\n * // .intlayer/fetch_dictionary/home.cjs\n * ```\n */\nexport const writeFetchDictionary = async (\n  dynamicDictionaries: LocalizedDictionaryOutput,\n  configuration: IntlayerConfig,\n  formats: ('cjs' | 'esm')[] = OUTPUT_FORMAT\n): Promise<LocalizedDictionaryOutput> => {\n  const { fetchDictionariesDir, dynamicDictionariesDir } = configuration.system;\n  const { locales } = configuration.internationalization;\n\n  // Compute relative path from fetch dir to dynamic dir\n  let relativePrefix = normalizePath(\n    relative(fetchDictionariesDir, dynamicDictionariesDir)\n  );\n  if (!relativePrefix.startsWith('.')) {\n    relativePrefix = `./${relativePrefix}`;\n  }\n\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(Object.entries(dynamicDictionaries), async ([key]) => {\n    if (key === 'undefined') return;\n\n    await parallelize(formats, async (format) => {\n      const extension = format === 'cjs' ? 'cjs' : 'mjs';\n      const content = generateDictionaryEntryPoint(\n        key,\n        locales,\n        relativePrefix,\n        format\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  return resultDictionariesPaths;\n};\n"],"mappings":";;;;;;;;;;;AAUA,MAAa,gCACX,KACA,SACA,gBACA,SAAwB,UACb;CACX,MAAM,YAAY,WAAW,QAAQ,QAAQ;CAE7C,MAAM,gBAAgB,QACnB,MAAM,GAAG,MAAM,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CAAC,CAClD,KACE,WACC,MAAM,OAAO,mGAE0D,IAAI,GAAG,OAAO,gFAGzD,OAAO,mBAGtC,CACA,KAAK,MAAM;AAEd,KAAI,WAAW,MACb,QACE,+DAC2B,eAAe,GAAG,IAAI,GAAG,UAAU,2BACxC,cAAc;AAIxC,QACE,wEAC+B,eAAe,GAAG,IAAI,GAAG,UAAU,6BAC3C,cAAc;;;;;;;;;;;;;;;;;;AAoBzC,MAAa,uBAAuB,OAClC,qBACA,eACA,UAA6BA,iDACU;CACvC,MAAM,EAAE,sBAAsB,2BAA2B,cAAc;CACvE,MAAM,EAAE,YAAY,cAAc;CAGlC,IAAI,mFACO,sBAAsB,uBAAuB,CACvD;AACD,KAAI,CAAC,eAAe,WAAW,IAAI,CACjC,kBAAiB,KAAK;AAGxB,0DAAoB,qBAAqB,EAAE,EAAE,WAAW,MAAM,CAAC;CAE/D,MAAM,0BAAqD,EAAE;AAG7D,OAAMC,sCAAY,OAAO,QAAQ,oBAAoB,EAAE,OAAO,CAAC,SAAS;AACtE,MAAI,QAAQ,YAAa;AAEzB,QAAMA,sCAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;GAC7C,MAAM,UAAU,6BACd,KACA,SACA,gBACA,OACD;AAED,SAAMC,qEACI,sBAAsB,GAAG,IAAI,GAAG,YAAY,EACpD,QACD,CAAC,OAAO,QAAQ;AACf,YAAQ,MACN,yFAA6C,sBAAsB,GAAG,IAAI,GAAG,YAAY,CAAC,CAAC,IAC3F,IACD;KACD;IACF;GACF;AAEF,QAAO"}

package/dist/cjs/buildIntlayerDictionary/writeRemoteDictionary.cjs

@@ -33,7 +33,7 @@ const writeRemoteDictionary = async (remoteDictionaries, configuration) => {
 	const groupedDictionaries = require_buildIntlayerDictionary_writeUnmergedDictionary.groupDictionariesByKey(require_filterInvalidDictionaries.filterInvalidDictionaries(remoteDictionaries, configuration));
 	const results = await require_utils_parallelize.parallelize(Object.entries(groupedDictionaries), async ([key, dictionaries]) => {
 		if (key === "undefined") return;
-		const orderedDictionaries = (0, _intlayer_core_dictionaryManipulator.orderDictionaries)(require_loadDictionaries_loadRemoteDictionaries.formatDistantDictionaries(dictionaries), configuration);
+		const orderedDictionaries = (0, _intlayer_core_dictionaryManipulator.orderDictionaries)(require_loadDictionaries_loadRemoteDictionaries.formatDistantDictionaries(dictionaries));
 		const unmergedFilePath = (0, node_path.resolve)(remoteDictionariesDir, `${key}.json`);
 		await require_writeJsonIfChanged.writeJsonIfChanged(unmergedFilePath, orderedDictionaries).catch((err) => {
 			console.error(`${_intlayer_config_logger.x} Error creating unmerged ${(0, _intlayer_config_logger.colorizePath)(unmergedFilePath)}:`, err);

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

package/dist/cjs/buildIntlayerDictionary/writeUnmergedDictionary.cjs

@@ -41,7 +41,7 @@ const writeUnmergedDictionaries = async (dictionaries, configuration, env) => {
 	const groupedDictionaries = groupDictionariesByKey(require_filterInvalidDictionaries.filterInvalidDictionaries(dictionaries, configuration, { checkSchema: true }));
 	const results = await require_utils_parallelize.parallelize(Object.entries(groupedDictionaries), async ([key, dictionaries]) => {
 		if (key === "undefined") return;
-		const orderedDictionaries = (0, _intlayer_core_dictionaryManipulator.orderDictionaries)(dictionaries, configuration);
+		const orderedDictionaries = (0, _intlayer_core_dictionaryManipulator.orderDictionaries)(dictionaries);
 		const unmergedFilePath = (0, node_path.resolve)(unmergedDictionariesDir, `${key}.json`);
 		if (configuration.editor.enabled || env === "dev") await require_writeJsonIfChanged.writeJsonIfChanged(unmergedFilePath, orderedDictionaries).catch((err) => {
 			console.error(`${_intlayer_config_logger.x} Error creating unmerged ${(0, _intlayer_config_logger.colorizePath)(unmergedFilePath)}:`, err);

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

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

package/dist/esm/buildIntlayerDictionary/writeDynamicDictionary.mjs

@@ -9,38 +9,13 @@ import { getPerLocaleDictionary } from "@intlayer/core/plugins";
 
 //#region src/buildIntlayerDictionary/writeDynamicDictionary.ts
 const DICTIONARIES_SUBDIR = "json";
-const LOAD_CONTENT_MODULE = "_loadjson";
-/**
-* Assembles the entry point file content from a pre-built preamble (import/require line),
-* the locale→path record, the dictionary key, and the output format.
-* Shared by all dictionary entry point generators.
-*/
-const buildEntryPointContent = (preamble, localizedDictionariesPathsRecord, key, format = "esm") => {
-	const formattedDictionaryMap = Object.keys(localizedDictionariesPathsRecord).sort((a, b) => String(a).localeCompare(String(b))).map((locale) => `  '${locale}': () => loadContent('${key}', '${locale}')`).join(",\n");
-	let content = preamble;
-	content += `const content = {\n${formattedDictionaryMap}\n};\n\n`;
-	if (format === "esm") content += `export default content;\n`;
-	if (format === "cjs") content += `module.exports = content;\n`;
-	return content;
-};
-/**
-* Generates the content of the shared `loadContent` module written once per
-* output directory. Locales are baked in so each dynamic import has only one
-* variable (`key`), making it statically analyzable by Vite/Rollup.
-*/
-const generateDynamicLoadContentModule = (format, locales) => {
-	const body = `const loadContent = (key) => ({\n${[...locales].sort((a, b) => String(a).localeCompare(String(b))).map((locale) => format === "esm" ? `  '${locale}': () => import(\`./${DICTIONARIES_SUBDIR}/\${key}/${locale}.json\`).then(m => m.default)` : `  '${locale}': () => Promise.resolve(require(\`./${DICTIONARIES_SUBDIR}/\${key}/${locale}.json\`))`).join(",\n")}\n});\n`;
-	if (format === "esm") return `${body}\nexport { loadContent };\n`;
-	return `${body}\nmodule.exports = { loadContent };\n`;
-};
 /**
 * Generates the content of a dictionary entry point file.
-* `loadContent` is imported from the shared module and called with the key.
 */
-const generateDictionaryEntryPoint = (key, format = "esm") => {
-	const extension = format === "cjs" ? "cjs" : "mjs";
-	if (format === "esm") return `import { loadContent } from './${LOAD_CONTENT_MODULE}.${extension}';\n\nconst content = loadContent('${key}');\n\nexport default content;\n`;
-	return `const { loadContent } = require('./${LOAD_CONTENT_MODULE}.${extension}');\n\nmodule.exports = loadContent('${key}');\n`;
+const generateDictionaryEntryPoint = (key, locales, format = "esm") => {
+	const localeEntries = [...locales].sort((a, b) => String(a).localeCompare(String(b))).map((locale) => format === "esm" ? `  '${locale}': () => import('./${DICTIONARIES_SUBDIR}/${key}/${locale}.json').then(m => m.default)` : `  '${locale}': () => Promise.resolve(require('./${DICTIONARIES_SUBDIR}/${key}/${locale}.json'))`).join(",\n");
+	if (format === "esm") return `const content = {\n${localeEntries}\n};\n\nexport default content;\n`;
+	return `module.exports = {\n${localeEntries}\n};\n`;
 };
 /**
 * Write the localized dictionaries to the dictionariesDir
@@ -63,12 +38,6 @@ const writeDynamicDictionary = async (mergedDictionaries, configuration, formats
 	const { dynamicDictionariesDir } = configuration.system;
 	const dictDir = resolve(dynamicDictionariesDir, DICTIONARIES_SUBDIR);
 	await mkdir(dictDir, { recursive: true });
-	await parallelize(formats, async (format) => {
-		const extension = format === "cjs" ? "cjs" : "mjs";
-		await writeFileIfChanged(resolve(dynamicDictionariesDir, `${LOAD_CONTENT_MODULE}.${extension}`), generateDynamicLoadContentModule(format, locales)).catch((err) => {
-			console.error(`Error creating dynamic ${colorizePath(resolve(dynamicDictionariesDir, `${LOAD_CONTENT_MODULE}.${extension}`))}:`, err);
-		});
-	});
 	const resultDictionariesPaths = {};
 	await parallelize(Object.entries(mergedDictionaries).sort(([a], [b]) => String(a).localeCompare(String(b))), async ([key, dictionaryEntry]) => {
 		if (key === "undefined") return;
@@ -89,7 +58,7 @@ const writeDynamicDictionary = async (mergedDictionaries, configuration, formats
 		resultDictionariesPaths[key] = localizedDictionariesPathsRecord;
 		await parallelize(formats, async (format) => {
 			const extension = format === "cjs" ? "cjs" : "mjs";
-			const content = generateDictionaryEntryPoint(key, format);
+			const content = generateDictionaryEntryPoint(key, locales, format);
 			await writeFileIfChanged(resolve(dynamicDictionariesDir, `${key}.${extension}`), content).catch((err) => {
 				console.error(`Error creating dynamic ${colorizePath(resolve(dynamicDictionariesDir, `${key}.${extension}`))}:`, err);
 			});
@@ -99,5 +68,5 @@ const writeDynamicDictionary = async (mergedDictionaries, configuration, formats
 };
 
 //#endregion
-export { buildEntryPointContent, generateDictionaryEntryPoint, generateDynamicLoadContentModule, writeDynamicDictionary };
+export { generateDictionaryEntryPoint, writeDynamicDictionary };
 //# sourceMappingURL=writeDynamicDictionary.mjs.map

package/dist/esm/buildIntlayerDictionary/writeDynamicDictionary.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"writeDynamicDictionary.mjs","names":[],"sources":["../../../src/buildIntlayerDictionary/writeDynamicDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { OUTPUT_FORMAT } from '@intlayer/config/defaultValues';\nimport { colorizePath } from '@intlayer/config/logger';\nimport { getPerLocaleDictionary } from '@intlayer/core/plugins';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\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\nconst DICTIONARIES_SUBDIR = 'json'; // Necessary to add a static first dir for Turbopack\nconst LOAD_CONTENT_MODULE = '_loadjson';\n\n/**\n * Assembles the entry point file content from a pre-built preamble (import/require line),\n * the locale→path record, the dictionary key, and the output format.\n * Shared by all dictionary entry point generators.\n */\nexport const buildEntryPointContent = (\n  preamble: string,\n  localizedDictionariesPathsRecord: LocalizedDictionaryResult,\n  key: string,\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  const formattedDictionaryMap: string = Object.keys(\n    localizedDictionariesPathsRecord\n  )\n    .sort((a, b) => String(a).localeCompare(String(b)))\n    .map((locale) => `  '${locale}': () => loadContent('${key}', '${locale}')`)\n    .join(',\\n');\n\n  let content = preamble;\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 * Generates the content of the shared `loadContent` module written once per\n * output directory. Locales are baked in so each dynamic import has only one\n * variable (`key`), making it statically analyzable by Vite/Rollup.\n */\nexport const generateDynamicLoadContentModule = (\n  format: 'cjs' | 'esm',\n  locales: string[]\n): string => {\n  const sortedLocales = [...locales].sort((a, b) =>\n    String(a).localeCompare(String(b))\n  );\n\n  const localeEntries = sortedLocales\n    .map((locale) =>\n      format === 'esm'\n        ? `  '${locale}': () => import(\\`./${DICTIONARIES_SUBDIR}/\\${key}/${locale}.json\\`).then(m => m.default)`\n        : `  '${locale}': () => Promise.resolve(require(\\`./${DICTIONARIES_SUBDIR}/\\${key}/${locale}.json\\`))`\n    )\n    .join(',\\n');\n\n  const body = `const loadContent = (key) => ({\\n${localeEntries}\\n});\\n`;\n\n  if (format === 'esm') return `${body}\\nexport { loadContent };\\n`;\n  return `${body}\\nmodule.exports = { loadContent };\\n`;\n};\n\n/**\n * Generates the content of a dictionary entry point file.\n * `loadContent` is imported from the shared module and called with the key.\n */\nexport const generateDictionaryEntryPoint = (\n  key: string,\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n  if (format === 'esm') {\n    return (\n      `import { loadContent } from './${LOAD_CONTENT_MODULE}.${extension}';\\n\\n` +\n      `const content = loadContent('${key}');\\n\\n` +\n      `export default content;\\n`\n    );\n  }\n  return (\n    `const { loadContent } = require('./${LOAD_CONTENT_MODULE}.${extension}');\\n\\n` +\n    `module.exports = loadContent('${key}');\\n`\n  );\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_dictionary/dictionaries/en_home.json\n * // .intlayer/dynamic_dictionary/dictionaries/fr_home.json\n * ```\n */\nexport const writeDynamicDictionary = async (\n  mergedDictionaries: MergedDictionaryOutput,\n  configuration: IntlayerConfig,\n  formats: ('cjs' | 'esm')[] = OUTPUT_FORMAT\n): Promise<LocalizedDictionaryOutput> => {\n  const { locales, defaultLocale } = configuration.internationalization;\n  const { dynamicDictionariesDir } = configuration.system;\n\n  const dictDir = resolve(dynamicDictionariesDir, DICTIONARIES_SUBDIR);\n  await mkdir(dictDir, { recursive: true });\n  await parallelize(formats, async (format) => {\n    const extension = format === 'cjs' ? 'cjs' : 'mjs';\n    await writeFileIfChanged(\n      resolve(dynamicDictionariesDir, `${LOAD_CONTENT_MODULE}.${extension}`),\n      generateDynamicLoadContentModule(format, locales)\n    ).catch((err) => {\n      console.error(\n        `Error creating dynamic ${colorizePath(resolve(dynamicDictionariesDir, `${LOAD_CONTENT_MODULE}.${extension}`))}:`,\n        err\n      );\n    });\n  });\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      const keyDir = resolve(dictDir, key);\n      await mkdir(keyDir, { recursive: true });\n\n      await parallelize(locales, async (locale) => {\n        const localizedDictionary = getPerLocaleDictionary(\n          dictionaryEntry.dictionary,\n          locale,\n          defaultLocale\n        );\n\n        // Directory structure: json/key/locale.json\n        const resultFilePath = resolve(keyDir, `${locale}.json`);\n\n        await writeJsonIfChanged(resultFilePath, localizedDictionary).catch(\n          (err) => {\n            console.error(\n              `Error creating localized ${key}/${locale}.json:`,\n              err\n            );\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(key, format);\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":";;;;;;;;;;AA2BA,MAAM,sBAAsB;AAC5B,MAAM,sBAAsB;;;;;;AAO5B,MAAa,0BACX,UACA,kCACA,KACA,SAAwB,UACb;CACX,MAAM,yBAAiC,OAAO,KAC5C,iCACD,CACE,MAAM,GAAG,MAAM,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CAAC,CAClD,KAAK,WAAW,MAAM,OAAO,wBAAwB,IAAI,MAAM,OAAO,IAAI,CAC1E,KAAK,MAAM;CAEd,IAAI,UAAU;AACd,YAAW,sBAAsB,uBAAuB;AACxD,KAAI,WAAW,MAAO,YAAW;AACjC,KAAI,WAAW,MAAO,YAAW;AAEjC,QAAO;;;;;;;AAQT,MAAa,oCACX,QACA,YACW;CAaX,MAAM,OAAO,oCAZS,CAAC,GAAG,QAAQ,CAAC,MAAM,GAAG,MAC1C,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CACnC,CAGE,KAAK,WACJ,WAAW,QACP,MAAM,OAAO,sBAAsB,oBAAoB,WAAW,OAAO,iCACzE,MAAM,OAAO,uCAAuC,oBAAoB,WAAW,OAAO,WAC/F,CACA,KAAK,MAAM,CAEiD;AAE/D,KAAI,WAAW,MAAO,QAAO,GAAG,KAAK;AACrC,QAAO,GAAG,KAAK;;;;;;AAOjB,MAAa,gCACX,KACA,SAAwB,UACb;CACX,MAAM,YAAY,WAAW,QAAQ,QAAQ;AAC7C,KAAI,WAAW,MACb,QACE,kCAAkC,oBAAoB,GAAG,UAAU,qCACnC,IAAI;AAIxC,QACE,sCAAsC,oBAAoB,GAAG,UAAU,uCACtC,IAAI;;;;;;;;;;;;;;;;;;AAoBzC,MAAa,yBAAyB,OACpC,oBACA,eACA,UAA6B,kBACU;CACvC,MAAM,EAAE,SAAS,kBAAkB,cAAc;CACjD,MAAM,EAAE,2BAA2B,cAAc;CAEjD,MAAM,UAAU,QAAQ,wBAAwB,oBAAoB;AACpE,OAAM,MAAM,SAAS,EAAE,WAAW,MAAM,CAAC;AACzC,OAAM,YAAY,SAAS,OAAO,WAAW;EAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;AAC7C,QAAM,mBACJ,QAAQ,wBAAwB,GAAG,oBAAoB,GAAG,YAAY,EACtE,iCAAiC,QAAQ,QAAQ,CAClD,CAAC,OAAO,QAAQ;AACf,WAAQ,MACN,0BAA0B,aAAa,QAAQ,wBAAwB,GAAG,oBAAoB,GAAG,YAAY,CAAC,CAAC,IAC/G,IACD;IACD;GACF;CAEF,MAAM,0BAAqD,EAAE;AAG7D,OAAM,YACJ,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,MAAM,mCAA8D,EAAE;EAEtE,MAAM,SAAS,QAAQ,SAAS,IAAI;AACpC,QAAM,MAAM,QAAQ,EAAE,WAAW,MAAM,CAAC;AAExC,QAAM,YAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,sBAAsB,uBAC1B,gBAAgB,YAChB,QACA,cACD;GAGD,MAAM,iBAAiB,QAAQ,QAAQ,GAAG,OAAO,OAAO;AAExD,SAAM,mBAAmB,gBAAgB,oBAAoB,CAAC,OAC3D,QAAQ;AACP,YAAQ,MACN,4BAA4B,IAAI,GAAG,OAAO,SAC1C,IACD;KAEJ;AAED,oCAAiC,UAAU;IACzC,gBAAgB;IAChB,YAAY;IACb;IACD;AAEF,0BAAwB,OAAO;AAE/B,QAAM,YAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;GAC7C,MAAM,UAAU,6BAA6B,KAAK,OAAO;AAEzD,SAAM,mBACJ,QAAQ,wBAAwB,GAAG,IAAI,GAAG,YAAY,EACtD,QACD,CAAC,OAAO,QAAQ;AACf,YAAQ,MACN,0BAA0B,aAAa,QAAQ,wBAAwB,GAAG,IAAI,GAAG,YAAY,CAAC,CAAC,IAC/F,IACD;KACD;IACF;GAEL;AAED,QAAO"}
+{"version":3,"file":"writeDynamicDictionary.mjs","names":[],"sources":["../../../src/buildIntlayerDictionary/writeDynamicDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { OUTPUT_FORMAT } from '@intlayer/config/defaultValues';\nimport { colorizePath } from '@intlayer/config/logger';\nimport { getPerLocaleDictionary } from '@intlayer/core/plugins';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\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\nconst DICTIONARIES_SUBDIR = 'json'; // Necessary to add a static first dir for Turbopack\n\n/**\n * Generates the content of a dictionary entry point file.\n */\nexport const generateDictionaryEntryPoint = (\n  key: string,\n  locales: string[],\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  const sortedLocales = [...locales].sort((a, b) =>\n    String(a).localeCompare(String(b))\n  );\n\n  const localeEntries = sortedLocales\n    .map((locale) =>\n      format === 'esm'\n        ? `  '${locale}': () => import('./${DICTIONARIES_SUBDIR}/${key}/${locale}.json').then(m => m.default)`\n        : `  '${locale}': () => Promise.resolve(require('./${DICTIONARIES_SUBDIR}/${key}/${locale}.json'))`\n    )\n    .join(',\\n');\n\n  if (format === 'esm') {\n    return (\n      `const content = {\\n${localeEntries}\\n};\\n\\n` +\n      `export default content;\\n`\n    );\n  }\n  return `module.exports = {\\n${localeEntries}\\n};\\n`;\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_dictionary/dictionaries/en_home.json\n * // .intlayer/dynamic_dictionary/dictionaries/fr_home.json\n * ```\n */\nexport const writeDynamicDictionary = async (\n  mergedDictionaries: MergedDictionaryOutput,\n  configuration: IntlayerConfig,\n  formats: ('cjs' | 'esm')[] = OUTPUT_FORMAT\n): Promise<LocalizedDictionaryOutput> => {\n  const { locales, defaultLocale } = configuration.internationalization;\n  const { dynamicDictionariesDir } = configuration.system;\n\n  const dictDir = resolve(dynamicDictionariesDir, DICTIONARIES_SUBDIR);\n  await mkdir(dictDir, { 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      const keyDir = resolve(dictDir, key);\n      await mkdir(keyDir, { recursive: true });\n\n      await parallelize(locales, async (locale) => {\n        const localizedDictionary = getPerLocaleDictionary(\n          dictionaryEntry.dictionary,\n          locale,\n          defaultLocale\n        );\n\n        // Directory structure: json/key/locale.json\n        const resultFilePath = resolve(keyDir, `${locale}.json`);\n\n        await writeJsonIfChanged(resultFilePath, localizedDictionary).catch(\n          (err) => {\n            console.error(\n              `Error creating localized ${key}/${locale}.json:`,\n              err\n            );\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(key, locales, format);\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":";;;;;;;;;;AA2BA,MAAM,sBAAsB;;;;AAK5B,MAAa,gCACX,KACA,SACA,SAAwB,UACb;CAKX,MAAM,gBAJgB,CAAC,GAAG,QAAQ,CAAC,MAAM,GAAG,MAC1C,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CACnC,CAGE,KAAK,WACJ,WAAW,QACP,MAAM,OAAO,qBAAqB,oBAAoB,GAAG,IAAI,GAAG,OAAO,gCACvE,MAAM,OAAO,sCAAsC,oBAAoB,GAAG,IAAI,GAAG,OAAO,UAC7F,CACA,KAAK,MAAM;AAEd,KAAI,WAAW,MACb,QACE,sBAAsB,cAAc;AAIxC,QAAO,uBAAuB,cAAc;;;;;;;;;;;;;;;;;;AAmB9C,MAAa,yBAAyB,OACpC,oBACA,eACA,UAA6B,kBACU;CACvC,MAAM,EAAE,SAAS,kBAAkB,cAAc;CACjD,MAAM,EAAE,2BAA2B,cAAc;CAEjD,MAAM,UAAU,QAAQ,wBAAwB,oBAAoB;AACpE,OAAM,MAAM,SAAS,EAAE,WAAW,MAAM,CAAC;CAEzC,MAAM,0BAAqD,EAAE;AAG7D,OAAM,YACJ,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,MAAM,mCAA8D,EAAE;EAEtE,MAAM,SAAS,QAAQ,SAAS,IAAI;AACpC,QAAM,MAAM,QAAQ,EAAE,WAAW,MAAM,CAAC;AAExC,QAAM,YAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,sBAAsB,uBAC1B,gBAAgB,YAChB,QACA,cACD;GAGD,MAAM,iBAAiB,QAAQ,QAAQ,GAAG,OAAO,OAAO;AAExD,SAAM,mBAAmB,gBAAgB,oBAAoB,CAAC,OAC3D,QAAQ;AACP,YAAQ,MACN,4BAA4B,IAAI,GAAG,OAAO,SAC1C,IACD;KAEJ;AAED,oCAAiC,UAAU;IACzC,gBAAgB;IAChB,YAAY;IACb;IACD;AAEF,0BAAwB,OAAO;AAE/B,QAAM,YAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;GAC7C,MAAM,UAAU,6BAA6B,KAAK,SAAS,OAAO;AAElE,SAAM,mBACJ,QAAQ,wBAAwB,GAAG,IAAI,GAAG,YAAY,EACtD,QACD,CAAC,OAAO,QAAQ;AACf,YAAQ,MACN,0BAA0B,aAAa,QAAQ,wBAAwB,GAAG,IAAI,GAAG,YAAY,CAAC,CAAC,IAC/F,IACD;KACD;IACF;GAEL;AAED,QAAO"}

package/dist/esm/buildIntlayerDictionary/writeFetchDictionary.mjs

@@ -7,29 +7,11 @@ import { normalizePath } from "@intlayer/config/utils";
 import { OUTPUT_FORMAT } from "@intlayer/config/defaultValues";
 
 //#region src/buildIntlayerDictionary/writeFetchDictionary.ts
-const LOAD_CONTENT_MODULE = "_loadjson";
-/**
-* Generates the content of the shared `loadContent` module for fetch dictionaries.
-* - `configuration` is imported at runtime from "intlayer" (liveSyncURL not baked in).
-* - Fallback delegates to the dynamic dictionary's `_loadjson` module.
-* - Locales are baked in so each entry is a static function referencing one locale.
-*/
-const generateFetchLoadContentModule = (format, relativePrefix, locales) => {
-	const sortedLocales = [...locales].sort((a, b) => String(a).localeCompare(String(b)));
-	const extension = format === "cjs" ? "cjs" : "mjs";
-	const body = `const loadContent = (key) => {
-  const dynContent = loadContentDyn(key);
-  return {\n${sortedLocales.map((locale) => `  '${locale}': async () => {\n    try {\n      const res = await fetch(\`\${editor.liveSyncURL}/dictionaries/\${key}/${locale}\`);\n      return await res.json();\n    } catch {\n      return dynContent['${locale}']();\n    }\n  }`).join(",\n")}\n  };\n};\n`;
-	if (format === "esm") return `import { editor } from 'intlayer';\nimport { loadContent as loadContentDyn } from '${relativePrefix}/${LOAD_CONTENT_MODULE}.${extension}';\n\n${body}\nexport { loadContent };\n`;
-	return `const { editor } = require('intlayer');\nconst { loadContent: loadContentDyn } = require('${relativePrefix}/${LOAD_CONTENT_MODULE}.${extension}');\n\n${body}\nmodule.exports = { loadContent };\n`;
-};
-/**
-* Generates the content of a fetch dictionary entry point file.
-*/
-const generateDictionaryEntryPoint = (key, format = "esm") => {
+const generateDictionaryEntryPoint = (key, locales, relativePrefix, format = "esm") => {
 	const extension = format === "cjs" ? "cjs" : "mjs";
-	if (format === "esm") return `import { loadContent } from './${LOAD_CONTENT_MODULE}.${extension}';\n\nconst content = loadContent('${key}');\n\nexport default content;\n`;
-	return `const { loadContent } = require('./${LOAD_CONTENT_MODULE}.${extension}');\n\nmodule.exports = loadContent('${key}');\n`;
+	const localeEntries = locales.sort((a, b) => String(a).localeCompare(String(b))).map((locale) => `  '${locale}': async () => {\n    try {\n      const res = await fetch(\`\${editor.liveSyncURL}/dictionaries/${key}/${locale}\`);\n      return await res.json();\n    } catch {\n      return dynContent['${locale}']();\n    }\n  }`).join(",\n");
+	if (format === "esm") return `import { editor } from 'intlayer';\nimport dynContent from '${relativePrefix}/${key}.${extension}';\n\nconst content = {\n${localeEntries}\n};\n\nexport default content;\n`;
+	return `const { editor } = require('intlayer');\nconst dynContent = require('${relativePrefix}/${key}.${extension}');\n\nmodule.exports = {\n${localeEntries}\n};\n`;
 };
 /**
 * Write the localized dictionaries to the dictionariesDir
@@ -53,18 +35,12 @@ const writeFetchDictionary = async (dynamicDictionaries, configuration, formats
 	let relativePrefix = normalizePath(relative(fetchDictionariesDir, dynamicDictionariesDir));
 	if (!relativePrefix.startsWith(".")) relativePrefix = `./${relativePrefix}`;
 	await mkdir(resolve(fetchDictionariesDir), { recursive: true });
-	await parallelize(formats, async (format) => {
-		const extension = format === "cjs" ? "cjs" : "mjs";
-		await writeFileIfChanged(resolve(fetchDictionariesDir, `${LOAD_CONTENT_MODULE}.${extension}`), generateFetchLoadContentModule(format, relativePrefix, locales)).catch((err) => {
-			console.error(`Error creating fetch ${colorizePath(resolve(fetchDictionariesDir, `${LOAD_CONTENT_MODULE}.${extension}`))}:`, err);
-		});
-	});
 	const resultDictionariesPaths = {};
 	await parallelize(Object.entries(dynamicDictionaries), async ([key]) => {
 		if (key === "undefined") return;
 		await parallelize(formats, async (format) => {
 			const extension = format === "cjs" ? "cjs" : "mjs";
-			const content = generateDictionaryEntryPoint(key, format);
+			const content = generateDictionaryEntryPoint(key, locales, relativePrefix, format);
 			await writeFileIfChanged(resolve(fetchDictionariesDir, `${key}.${extension}`), content).catch((err) => {
 				console.error(`Error creating fetch ${colorizePath(resolve(fetchDictionariesDir, `${key}.${extension}`))}:`, err);
 			});
@@ -74,5 +50,5 @@ const writeFetchDictionary = async (dynamicDictionaries, configuration, formats
 };
 
 //#endregion
-export { generateDictionaryEntryPoint, generateFetchLoadContentModule, writeFetchDictionary };
+export { generateDictionaryEntryPoint, writeFetchDictionary };
 //# sourceMappingURL=writeFetchDictionary.mjs.map

package/dist/esm/buildIntlayerDictionary/writeFetchDictionary.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"writeFetchDictionary.mjs","names":[],"sources":["../../../src/buildIntlayerDictionary/writeFetchDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { relative, resolve } from 'node:path';\nimport { OUTPUT_FORMAT } from '@intlayer/config/defaultValues';\nimport { colorizePath } from '@intlayer/config/logger';\nimport { normalizePath } from '@intlayer/config/utils';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport { parallelize } from '../utils/parallelize';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\nimport type { LocalizedDictionaryOutput } from './writeDynamicDictionary';\n\nconst LOAD_CONTENT_MODULE = '_loadjson';\n\n/**\n * Generates the content of the shared `loadContent` module for fetch dictionaries.\n * - `configuration` is imported at runtime from \"intlayer\" (liveSyncURL not baked in).\n * - Fallback delegates to the dynamic dictionary's `_loadjson` module.\n * - Locales are baked in so each entry is a static function referencing one locale.\n */\nexport const generateFetchLoadContentModule = (\n  format: 'cjs' | 'esm',\n  relativePrefix: string,\n  locales: string[]\n): string => {\n  const sortedLocales = [...locales].sort((a, b) =>\n    String(a).localeCompare(String(b))\n  );\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n\n  const localeEntries = sortedLocales\n    .map(\n      (locale) =>\n        `  '${locale}': async () => {\\n` +\n        `    try {\\n` +\n        `      const res = await fetch(\\`\\${editor.liveSyncURL}/dictionaries/\\${key}/${locale}\\`);\\n` +\n        `      return await res.json();\\n` +\n        `    } catch {\\n` +\n        `      return dynContent['${locale}']();\\n` +\n        `    }\\n` +\n        `  }`\n    )\n    .join(',\\n');\n\n  const body =\n    `const loadContent = (key) => {\\n` +\n    `  const dynContent = loadContentDyn(key);\\n` +\n    `  return {\\n${localeEntries}\\n  };\\n` +\n    `};\\n`;\n\n  if (format === 'esm') {\n    return (\n      `import { editor } from 'intlayer';\\n` +\n      `import { loadContent as loadContentDyn } from '${relativePrefix}/${LOAD_CONTENT_MODULE}.${extension}';\\n\\n` +\n      `${body}\\nexport { loadContent };\\n`\n    );\n  }\n  return (\n    `const { editor } = require('intlayer');\\n` +\n    `const { loadContent: loadContentDyn } = require('${relativePrefix}/${LOAD_CONTENT_MODULE}.${extension}');\\n\\n` +\n    `${body}\\nmodule.exports = { loadContent };\\n`\n  );\n};\n\n/**\n * Generates the content of a fetch dictionary entry point file.\n */\nexport const generateDictionaryEntryPoint = (\n  key: string,\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n  if (format === 'esm') {\n    return (\n      `import { loadContent } from './${LOAD_CONTENT_MODULE}.${extension}';\\n\\n` +\n      `const content = loadContent('${key}');\\n\\n` +\n      `export default content;\\n`\n    );\n  }\n  return (\n    `const { loadContent } = require('./${LOAD_CONTENT_MODULE}.${extension}');\\n\\n` +\n    `module.exports = loadContent('${key}');\\n`\n  );\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_dictionary/home.mjs\n * // .intlayer/fetch_dictionary/home.cjs\n * ```\n */\nexport const writeFetchDictionary = async (\n  dynamicDictionaries: LocalizedDictionaryOutput,\n  configuration: IntlayerConfig,\n  formats: ('cjs' | 'esm')[] = OUTPUT_FORMAT\n): Promise<LocalizedDictionaryOutput> => {\n  const { fetchDictionariesDir, dynamicDictionariesDir } = configuration.system;\n  const { locales } = configuration.internationalization;\n\n  // Compute relative path from fetch dir (where _loadjson lives) to dynamic dir\n  let relativePrefix = normalizePath(\n    relative(fetchDictionariesDir, dynamicDictionariesDir)\n  );\n  if (!relativePrefix.startsWith('.')) {\n    relativePrefix = `./${relativePrefix}`;\n  }\n\n  await mkdir(resolve(fetchDictionariesDir), { recursive: true });\n\n  // Write the shared loadContent module once per format\n  await parallelize(formats, async (format) => {\n    const extension = format === 'cjs' ? 'cjs' : 'mjs';\n    await writeFileIfChanged(\n      resolve(fetchDictionariesDir, `${LOAD_CONTENT_MODULE}.${extension}`),\n      generateFetchLoadContentModule(format, relativePrefix, locales)\n    ).catch((err) => {\n      console.error(\n        `Error creating fetch ${colorizePath(resolve(fetchDictionariesDir, `${LOAD_CONTENT_MODULE}.${extension}`))}:`,\n        err\n      );\n    });\n  });\n\n  const resultDictionariesPaths: LocalizedDictionaryOutput = {};\n\n  // Write entry points for each dictionary in parallel\n  await parallelize(Object.entries(dynamicDictionaries), async ([key]) => {\n    if (key === 'undefined') return;\n\n    await parallelize(formats, async (format) => {\n      const extension = format === 'cjs' ? 'cjs' : 'mjs';\n      const content = generateDictionaryEntryPoint(key, format);\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  return resultDictionariesPaths;\n};\n"],"mappings":";;;;;;;;;AAUA,MAAM,sBAAsB;;;;;;;AAQ5B,MAAa,kCACX,QACA,gBACA,YACW;CACX,MAAM,gBAAgB,CAAC,GAAG,QAAQ,CAAC,MAAM,GAAG,MAC1C,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CACnC;CACD,MAAM,YAAY,WAAW,QAAQ,QAAQ;CAgB7C,MAAM,OACJ;;cAfoB,cACnB,KACE,WACC,MAAM,OAAO,2GAEkE,OAAO,gFAG1D,OAAO,mBAGtC,CACA,KAAK,MAAM,CAKiB;AAG/B,KAAI,WAAW,MACb,QACE,sFACkD,eAAe,GAAG,oBAAoB,GAAG,UAAU,QAClG,KAAK;AAGZ,QACE,6FACoD,eAAe,GAAG,oBAAoB,GAAG,UAAU,SACpG,KAAK;;;;;AAOZ,MAAa,gCACX,KACA,SAAwB,UACb;CACX,MAAM,YAAY,WAAW,QAAQ,QAAQ;AAC7C,KAAI,WAAW,MACb,QACE,kCAAkC,oBAAoB,GAAG,UAAU,qCACnC,IAAI;AAIxC,QACE,sCAAsC,oBAAoB,GAAG,UAAU,uCACtC,IAAI;;;;;;;;;;;;;;;;;;AAoBzC,MAAa,uBAAuB,OAClC,qBACA,eACA,UAA6B,kBACU;CACvC,MAAM,EAAE,sBAAsB,2BAA2B,cAAc;CACvE,MAAM,EAAE,YAAY,cAAc;CAGlC,IAAI,iBAAiB,cACnB,SAAS,sBAAsB,uBAAuB,CACvD;AACD,KAAI,CAAC,eAAe,WAAW,IAAI,CACjC,kBAAiB,KAAK;AAGxB,OAAM,MAAM,QAAQ,qBAAqB,EAAE,EAAE,WAAW,MAAM,CAAC;AAG/D,OAAM,YAAY,SAAS,OAAO,WAAW;EAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;AAC7C,QAAM,mBACJ,QAAQ,sBAAsB,GAAG,oBAAoB,GAAG,YAAY,EACpE,+BAA+B,QAAQ,gBAAgB,QAAQ,CAChE,CAAC,OAAO,QAAQ;AACf,WAAQ,MACN,wBAAwB,aAAa,QAAQ,sBAAsB,GAAG,oBAAoB,GAAG,YAAY,CAAC,CAAC,IAC3G,IACD;IACD;GACF;CAEF,MAAM,0BAAqD,EAAE;AAG7D,OAAM,YAAY,OAAO,QAAQ,oBAAoB,EAAE,OAAO,CAAC,SAAS;AACtE,MAAI,QAAQ,YAAa;AAEzB,QAAM,YAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;GAC7C,MAAM,UAAU,6BAA6B,KAAK,OAAO;AAEzD,SAAM,mBACJ,QAAQ,sBAAsB,GAAG,IAAI,GAAG,YAAY,EACpD,QACD,CAAC,OAAO,QAAQ;AACf,YAAQ,MACN,wBAAwB,aAAa,QAAQ,sBAAsB,GAAG,IAAI,GAAG,YAAY,CAAC,CAAC,IAC3F,IACD;KACD;IACF;GACF;AAEF,QAAO"}
+{"version":3,"file":"writeFetchDictionary.mjs","names":[],"sources":["../../../src/buildIntlayerDictionary/writeFetchDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { relative, resolve } from 'node:path';\nimport { OUTPUT_FORMAT } from '@intlayer/config/defaultValues';\nimport { colorizePath } from '@intlayer/config/logger';\nimport { normalizePath } from '@intlayer/config/utils';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport { parallelize } from '../utils/parallelize';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\nimport type { LocalizedDictionaryOutput } from './writeDynamicDictionary';\n\nexport const generateDictionaryEntryPoint = (\n  key: string,\n  locales: string[],\n  relativePrefix: string,\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n\n  const localeEntries = locales\n    .sort((a, b) => String(a).localeCompare(String(b)))\n    .map(\n      (locale) =>\n        `  '${locale}': async () => {\\n` +\n        `    try {\\n` +\n        `      const res = await fetch(\\`\\${editor.liveSyncURL}/dictionaries/${key}/${locale}\\`);\\n` +\n        `      return await res.json();\\n` +\n        `    } catch {\\n` +\n        `      return dynContent['${locale}']();\\n` +\n        `    }\\n` +\n        `  }`\n    )\n    .join(',\\n');\n\n  if (format === 'esm') {\n    return (\n      `import { editor } from 'intlayer';\\n` +\n      `import dynContent from '${relativePrefix}/${key}.${extension}';\\n\\n` +\n      `const content = {\\n${localeEntries}\\n};\\n\\n` +\n      `export default content;\\n`\n    );\n  }\n  return (\n    `const { editor } = require('intlayer');\\n` +\n    `const dynContent = require('${relativePrefix}/${key}.${extension}');\\n\\n` +\n    `module.exports = {\\n${localeEntries}\\n};\\n`\n  );\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_dictionary/home.mjs\n * // .intlayer/fetch_dictionary/home.cjs\n * ```\n */\nexport const writeFetchDictionary = async (\n  dynamicDictionaries: LocalizedDictionaryOutput,\n  configuration: IntlayerConfig,\n  formats: ('cjs' | 'esm')[] = OUTPUT_FORMAT\n): Promise<LocalizedDictionaryOutput> => {\n  const { fetchDictionariesDir, dynamicDictionariesDir } = configuration.system;\n  const { locales } = configuration.internationalization;\n\n  // Compute relative path from fetch dir to dynamic dir\n  let relativePrefix = normalizePath(\n    relative(fetchDictionariesDir, dynamicDictionariesDir)\n  );\n  if (!relativePrefix.startsWith('.')) {\n    relativePrefix = `./${relativePrefix}`;\n  }\n\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(Object.entries(dynamicDictionaries), async ([key]) => {\n    if (key === 'undefined') return;\n\n    await parallelize(formats, async (format) => {\n      const extension = format === 'cjs' ? 'cjs' : 'mjs';\n      const content = generateDictionaryEntryPoint(\n        key,\n        locales,\n        relativePrefix,\n        format\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  return resultDictionariesPaths;\n};\n"],"mappings":";;;;;;;;;AAUA,MAAa,gCACX,KACA,SACA,gBACA,SAAwB,UACb;CACX,MAAM,YAAY,WAAW,QAAQ,QAAQ;CAE7C,MAAM,gBAAgB,QACnB,MAAM,GAAG,MAAM,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CAAC,CAClD,KACE,WACC,MAAM,OAAO,mGAE0D,IAAI,GAAG,OAAO,gFAGzD,OAAO,mBAGtC,CACA,KAAK,MAAM;AAEd,KAAI,WAAW,MACb,QACE,+DAC2B,eAAe,GAAG,IAAI,GAAG,UAAU,2BACxC,cAAc;AAIxC,QACE,wEAC+B,eAAe,GAAG,IAAI,GAAG,UAAU,6BAC3C,cAAc;;;;;;;;;;;;;;;;;;AAoBzC,MAAa,uBAAuB,OAClC,qBACA,eACA,UAA6B,kBACU;CACvC,MAAM,EAAE,sBAAsB,2BAA2B,cAAc;CACvE,MAAM,EAAE,YAAY,cAAc;CAGlC,IAAI,iBAAiB,cACnB,SAAS,sBAAsB,uBAAuB,CACvD;AACD,KAAI,CAAC,eAAe,WAAW,IAAI,CACjC,kBAAiB,KAAK;AAGxB,OAAM,MAAM,QAAQ,qBAAqB,EAAE,EAAE,WAAW,MAAM,CAAC;CAE/D,MAAM,0BAAqD,EAAE;AAG7D,OAAM,YAAY,OAAO,QAAQ,oBAAoB,EAAE,OAAO,CAAC,SAAS;AACtE,MAAI,QAAQ,YAAa;AAEzB,QAAM,YAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;GAC7C,MAAM,UAAU,6BACd,KACA,SACA,gBACA,OACD;AAED,SAAM,mBACJ,QAAQ,sBAAsB,GAAG,IAAI,GAAG,YAAY,EACpD,QACD,CAAC,OAAO,QAAQ;AACf,YAAQ,MACN,wBAAwB,aAAa,QAAQ,sBAAsB,GAAG,IAAI,GAAG,YAAY,CAAC,CAAC,IAC3F,IACD;KACD;IACF;GACF;AAEF,QAAO"}

package/dist/esm/buildIntlayerDictionary/writeRemoteDictionary.mjs

@@ -31,7 +31,7 @@ const writeRemoteDictionary = async (remoteDictionaries, configuration) => {
 	const groupedDictionaries = groupDictionariesByKey(filterInvalidDictionaries(remoteDictionaries, configuration));
 	const results = await parallelize(Object.entries(groupedDictionaries), async ([key, dictionaries]) => {
 		if (key === "undefined") return;
-		const orderedDictionaries = orderDictionaries(formatDistantDictionaries(dictionaries), configuration);
+		const orderedDictionaries = orderDictionaries(formatDistantDictionaries(dictionaries));
 		const unmergedFilePath = resolve(remoteDictionariesDir, `${key}.json`);
 		await writeJsonIfChanged(unmergedFilePath, orderedDictionaries).catch((err) => {
 			console.error(`${x} Error creating unmerged ${colorizePath(unmergedFilePath)}:`, err);

package/dist/esm/buildIntlayerDictionary/writeRemoteDictionary.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"writeRemoteDictionary.mjs","names":[],"sources":["../../../src/buildIntlayerDictionary/writeRemoteDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { colorizePath, x } from '@intlayer/config/logger';\nimport { orderDictionaries } from '@intlayer/core/dictionaryManipulator';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { filterInvalidDictionaries } from '../filterInvalidDictionaries';\nimport { formatDistantDictionaries } from '../loadDictionaries';\nimport { parallelize } from '../utils/parallelize';\nimport { writeJsonIfChanged } from '../writeJsonIfChanged';\nimport {\n  groupDictionariesByKey,\n  type UnmergedDictionaryResult,\n} from './writeUnmergedDictionary';\n\nexport type RemoteDictionaryResult = {\n  dictionaryPath: string;\n  dictionaries: Dictionary[];\n};\n\nexport type RemoteDictionaryOutput = Record<string, RemoteDictionaryResult>;\n\n/**\n * Write the localized dictionaries to the dictionariesDir\n * @param mergedDictionaries - The merged dictionaries\n * @param configuration - The configuration\n * @returns The final dictionaries\n *\n * @example\n * ```ts\n * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);\n * const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);\n * console.log(finalDictionaries);\n *\n * // .intlayer/fetch_dictionaries/home.json\n * // { key: 'home', content: { ... } },\n * ```\n */\nexport const writeRemoteDictionary = async (\n  remoteDictionaries: Dictionary[],\n  configuration: IntlayerConfig\n): Promise<RemoteDictionaryOutput> => {\n  const { remoteDictionariesDir } = configuration.system;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(remoteDictionariesDir), { recursive: true });\n\n  const filteredDictionaries = filterInvalidDictionaries(\n    remoteDictionaries,\n    configuration\n  );\n\n  //  Group dictionaries by key and write to unmergedDictionariesDir\n  const groupedDictionaries = groupDictionariesByKey(filteredDictionaries);\n\n  // Merge dictionaries with the same key and write to dictionariesDir\n  const results = await parallelize(\n    Object.entries(groupedDictionaries),\n    async ([key, dictionaries]) => {\n      if (key === 'undefined') {\n        return undefined as unknown as readonly [\n          string,\n          UnmergedDictionaryResult,\n        ];\n      }\n\n      const formattedDictionaries = formatDistantDictionaries(dictionaries);\n\n      const orderedDictionaries = orderDictionaries(\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,MAAa,wBAAwB,OACnC,oBACA,kBACoC;CACpC,MAAM,EAAE,0BAA0B,cAAc;AAGhD,OAAM,MAAM,QAAQ,sBAAsB,EAAE,EAAE,WAAW,MAAM,CAAC;CAQhE,MAAM,sBAAsB,uBANC,0BAC3B,oBACA,cACD,CAGuE;CAGxE,MAAM,UAAU,MAAM,YACpB,OAAO,QAAQ,oBAAoB,EACnC,OAAO,CAAC,KAAK,kBAAkB;AAC7B,MAAI,QAAQ,YACV;EAQF,MAAM,sBAAsB,kBAFE,0BAA0B,aAAa,EAInE,cACD;EAGD,MAAM,mBAAmB,QAAQ,uBADV,GAAG,IAAI,OACyC;AAGvE,QAAM,mBAAmB,kBAAkB,oBAAoB,CAAC,OAC7D,QAAQ;AACP,WAAQ,MACN,GAAG,EAAE,2BAA2B,aAAa,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.mjs","names":[],"sources":["../../../src/buildIntlayerDictionary/writeRemoteDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { colorizePath, x } from '@intlayer/config/logger';\nimport { orderDictionaries } from '@intlayer/core/dictionaryManipulator';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { filterInvalidDictionaries } from '../filterInvalidDictionaries';\nimport { formatDistantDictionaries } from '../loadDictionaries';\nimport { parallelize } from '../utils/parallelize';\nimport { writeJsonIfChanged } from '../writeJsonIfChanged';\nimport {\n  groupDictionariesByKey,\n  type UnmergedDictionaryResult,\n} from './writeUnmergedDictionary';\n\nexport type RemoteDictionaryResult = {\n  dictionaryPath: string;\n  dictionaries: Dictionary[];\n};\n\nexport type RemoteDictionaryOutput = Record<string, RemoteDictionaryResult>;\n\n/**\n * Write the localized dictionaries to the dictionariesDir\n * @param mergedDictionaries - The merged dictionaries\n * @param configuration - The configuration\n * @returns The final dictionaries\n *\n * @example\n * ```ts\n * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);\n * const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);\n * console.log(finalDictionaries);\n *\n * // .intlayer/fetch_dictionaries/home.json\n * // { key: 'home', content: { ... } },\n * ```\n */\nexport const writeRemoteDictionary = async (\n  remoteDictionaries: Dictionary[],\n  configuration: IntlayerConfig\n): Promise<RemoteDictionaryOutput> => {\n  const { remoteDictionariesDir } = configuration.system;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(remoteDictionariesDir), { recursive: true });\n\n  const filteredDictionaries = filterInvalidDictionaries(\n    remoteDictionaries,\n    configuration\n  );\n\n  //  Group dictionaries by key and write to unmergedDictionariesDir\n  const groupedDictionaries = groupDictionariesByKey(filteredDictionaries);\n\n  // Merge dictionaries with the same key and write to dictionariesDir\n  const results = await parallelize(\n    Object.entries(groupedDictionaries),\n    async ([key, dictionaries]) => {\n      if (key === 'undefined') {\n        return undefined as unknown as readonly [\n          string,\n          UnmergedDictionaryResult,\n        ];\n      }\n\n      const formattedDictionaries = formatDistantDictionaries(dictionaries);\n\n      const orderedDictionaries = orderDictionaries(formattedDictionaries);\n\n      const outputFileName = `${key}.json`;\n      const unmergedFilePath = resolve(remoteDictionariesDir, outputFileName);\n\n      // Write the grouped dictionaries\n      await writeJsonIfChanged(unmergedFilePath, orderedDictionaries).catch(\n        (err) => {\n          console.error(\n            `${x} Error creating unmerged ${colorizePath(unmergedFilePath)}:`,\n            err\n          );\n        }\n      );\n\n      return [\n        key,\n        {\n          dictionaryPath: unmergedFilePath,\n          dictionaries,\n        } as UnmergedDictionaryResult,\n      ] as const;\n    }\n  );\n\n  return Object.fromEntries(\n    results.filter(Boolean) as Array<\n      readonly [string, UnmergedDictionaryResult]\n    >\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,MAAa,wBAAwB,OACnC,oBACA,kBACoC;CACpC,MAAM,EAAE,0BAA0B,cAAc;AAGhD,OAAM,MAAM,QAAQ,sBAAsB,EAAE,EAAE,WAAW,MAAM,CAAC;CAQhE,MAAM,sBAAsB,uBANC,0BAC3B,oBACA,cACD,CAGuE;CAGxE,MAAM,UAAU,MAAM,YACpB,OAAO,QAAQ,oBAAoB,EACnC,OAAO,CAAC,KAAK,kBAAkB;AAC7B,MAAI,QAAQ,YACV;EAQF,MAAM,sBAAsB,kBAFE,0BAA0B,aAAa,CAED;EAGpE,MAAM,mBAAmB,QAAQ,uBADV,GAAG,IAAI,OACyC;AAGvE,QAAM,mBAAmB,kBAAkB,oBAAoB,CAAC,OAC7D,QAAQ;AACP,WAAQ,MACN,GAAG,EAAE,2BAA2B,aAAa,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/esm/buildIntlayerDictionary/writeUnmergedDictionary.mjs

@@ -39,7 +39,7 @@ const writeUnmergedDictionaries = async (dictionaries, configuration, env) => {
 	const groupedDictionaries = groupDictionariesByKey(filterInvalidDictionaries(dictionaries, configuration, { checkSchema: true }));
 	const results = await parallelize(Object.entries(groupedDictionaries), async ([key, dictionaries]) => {
 		if (key === "undefined") return;
-		const orderedDictionaries = orderDictionaries(dictionaries, configuration);
+		const orderedDictionaries = orderDictionaries(dictionaries);
 		const unmergedFilePath = resolve(unmergedDictionariesDir, `${key}.json`);
 		if (configuration.editor.enabled || env === "dev") await writeJsonIfChanged(unmergedFilePath, orderedDictionaries).catch((err) => {
 			console.error(`${x} Error creating unmerged ${colorizePath(unmergedFilePath)}:`, err);

package/dist/esm/buildIntlayerDictionary/writeUnmergedDictionary.mjs.map

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

package/dist/types/buildIntlayerDictionary/writeDynamicDictionary.d.ts

@@ -10,23 +10,10 @@ type DictionaryResult = {
 };
 type LocalizedDictionaryResult = Partial<Record<Locale, DictionaryResult>>;
 type LocalizedDictionaryOutput = Record<string, LocalizedDictionaryResult>;
-/**
- * Assembles the entry point file content from a pre-built preamble (import/require line),
- * the locale→path record, the dictionary key, and the output format.
- * Shared by all dictionary entry point generators.
- */
-declare const buildEntryPointContent: (preamble: string, localizedDictionariesPathsRecord: LocalizedDictionaryResult, key: string, format?: "cjs" | "esm") => string;
-/**
- * Generates the content of the shared `loadContent` module written once per
- * output directory. Locales are baked in so each dynamic import has only one
- * variable (`key`), making it statically analyzable by Vite/Rollup.
- */
-declare const generateDynamicLoadContentModule: (format: "cjs" | "esm", locales: string[]) => string;
 /**
  * Generates the content of a dictionary entry point file.
- * `loadContent` is imported from the shared module and called with the key.
  */
-declare const generateDictionaryEntryPoint: (key: string, format?: "cjs" | "esm") => string;
+declare const generateDictionaryEntryPoint: (key: string, locales: string[], format?: "cjs" | "esm") => string;
 /**
  * Write the localized dictionaries to the dictionariesDir
  * @param mergedDictionaries - The merged dictionaries
@@ -45,5 +32,5 @@ declare const generateDictionaryEntryPoint: (key: string, format?: "cjs" | "esm"
  */
 declare const writeDynamicDictionary: (mergedDictionaries: MergedDictionaryOutput, configuration: IntlayerConfig, formats?: ("cjs" | "esm")[]) => Promise<LocalizedDictionaryOutput>;
 //#endregion
-export { DictionaryResult, LocalizedDictionaryOutput, LocalizedDictionaryResult, buildEntryPointContent, generateDictionaryEntryPoint, generateDynamicLoadContentModule, writeDynamicDictionary };
+export { DictionaryResult, LocalizedDictionaryOutput, LocalizedDictionaryResult, generateDictionaryEntryPoint, writeDynamicDictionary };
 //# sourceMappingURL=writeDynamicDictionary.d.ts.map

package/dist/types/buildIntlayerDictionary/writeDynamicDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeDynamicDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeDynamicDictionary.ts"],"mappings":";;;;;;KAaY,gBAAA;EACV,cAAA;EACA,UAAA,EAAY,UAAA;AAAA;AAAA,KAGF,yBAAA,GAA4B,OAAA,CACtC,MAAA,CAAO,MAAA,EAAQ,gBAAA;AAAA,KAGL,yBAAA,GAA4B,MAAA,SAEtC,yBAAA;;;;;;cAWW,sBAAA,GACX,QAAA,UACA,gCAAA,EAAkC,yBAAA,EAClC,GAAA,UACA,MAAA;;;;;;cAsBW,gCAAA,GACX,MAAA,iBACA,OAAA;;;;;cAwBW,4BAAA,GACX,GAAA,UACA,MAAA;;;;AAnEF;;;;;AAaA;;;;;;;;cAsFa,sBAAA,GACX,kBAAA,EAAoB,sBAAA,EACpB,aAAA,EAAe,cAAA,EACf,OAAA,yBACC,OAAA,CAAQ,yBAAA"}
+{"version":3,"file":"writeDynamicDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeDynamicDictionary.ts"],"mappings":";;;;;;KAaY,gBAAA;EACV,cAAA;EACA,UAAA,EAAY,UAAA;AAAA;AAAA,KAGF,yBAAA,GAA4B,OAAA,CACtC,MAAA,CAAO,MAAA,EAAQ,gBAAA;AAAA,KAGL,yBAAA,GAA4B,MAAA,SAEtC,yBAAA;;;;cAQW,4BAAA,GACX,GAAA,UACA,OAAA,YACA,MAAA;;AAjBF;;;;;;;;;;;;;;;cAwDa,sBAAA,GACX,kBAAA,EAAoB,sBAAA,EACpB,aAAA,EAAe,cAAA,EACf,OAAA,yBACC,OAAA,CAAQ,yBAAA"}

package/dist/types/buildIntlayerDictionary/writeFetchDictionary.d.ts

@@ -2,17 +2,7 @@ import { LocalizedDictionaryOutput } from "./writeDynamicDictionary.js";
 import { IntlayerConfig } from "@intlayer/types/config";
 
 //#region src/buildIntlayerDictionary/writeFetchDictionary.d.ts
-/**
- * Generates the content of the shared `loadContent` module for fetch dictionaries.
- * - `configuration` is imported at runtime from "intlayer" (liveSyncURL not baked in).
- * - Fallback delegates to the dynamic dictionary's `_loadjson` module.
- * - Locales are baked in so each entry is a static function referencing one locale.
- */
-declare const generateFetchLoadContentModule: (format: "cjs" | "esm", relativePrefix: string, locales: string[]) => string;
-/**
- * Generates the content of a fetch dictionary entry point file.
- */
-declare const generateDictionaryEntryPoint: (key: string, format?: "cjs" | "esm") => string;
+declare const generateDictionaryEntryPoint: (key: string, locales: string[], relativePrefix: string, format?: "cjs" | "esm") => string;
 /**
  * Write the localized dictionaries to the dictionariesDir
  * @param mergedDictionaries - The merged dictionaries
@@ -31,5 +21,5 @@ declare const generateDictionaryEntryPoint: (key: string, format?: "cjs" | "esm"
  */
 declare const writeFetchDictionary: (dynamicDictionaries: LocalizedDictionaryOutput, configuration: IntlayerConfig, formats?: ("cjs" | "esm")[]) => Promise<LocalizedDictionaryOutput>;
 //#endregion
-export { generateDictionaryEntryPoint, generateFetchLoadContentModule, writeFetchDictionary };
+export { generateDictionaryEntryPoint, writeFetchDictionary };
 //# sourceMappingURL=writeFetchDictionary.d.ts.map

package/dist/types/buildIntlayerDictionary/writeFetchDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeFetchDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeFetchDictionary.ts"],"mappings":";;;;;;AAkBA;;;;cAAa,8BAAA,GACX,MAAA,iBACA,cAAA,UACA,OAAA;;;;cA4CW,4BAAA,GACX,GAAA,UACA,MAAA;AAFF;;;;;AAkCA;;;;;;;;;;;AAlCA,cAkCa,oBAAA,GACX,mBAAA,EAAqB,yBAAA,EACrB,aAAA,EAAe,cAAA,EACf,OAAA,yBACC,OAAA,CAAQ,yBAAA"}
+{"version":3,"file":"writeFetchDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeFetchDictionary.ts"],"mappings":";;;;cAUa,4BAAA,GACX,GAAA,UACA,OAAA,YACA,cAAA,UACA,MAAA;;AAJF;;;;;;;;;;AAsDA;;;;;cAAa,oBAAA,GACX,mBAAA,EAAqB,yBAAA,EACrB,aAAA,EAAe,cAAA,EACf,OAAA,yBACC,OAAA,CAAQ,yBAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/chokidar",
-  "version": "8.7.0",
+  "version": "8.7.1-canary-0",
   "private": false,
   "description": "Uses chokidar to scan and build Intlayer declaration files into dictionaries based on Intlayer configuration.",
   "keywords": [
@@ -109,13 +109,13 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "8.7.0",
-    "@intlayer/config": "8.7.0",
-    "@intlayer/core": "8.7.0",
-    "@intlayer/dictionaries-entry": "8.7.0",
-    "@intlayer/remote-dictionaries-entry": "8.7.0",
-    "@intlayer/types": "8.7.0",
-    "@intlayer/unmerged-dictionaries-entry": "8.7.0",
+    "@intlayer/api": "8.7.1-canary-0",
+    "@intlayer/config": "8.7.1-canary-0",
+    "@intlayer/core": "8.7.1-canary-0",
+    "@intlayer/dictionaries-entry": "8.7.1-canary-0",
+    "@intlayer/remote-dictionaries-entry": "8.7.1-canary-0",
+    "@intlayer/types": "8.7.1-canary-0",
+    "@intlayer/unmerged-dictionaries-entry": "8.7.1-canary-0",
     "chokidar": "3.6.0",
     "defu": "6.1.7",
     "fast-glob": "3.3.3",