@intlayer/chokidar 8.4.3 → 8.4.5

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 {\n  buildEntryPointContent,\n  type LocalizedDictionaryOutput,\n  type LocalizedDictionaryResult,\n} from './writeDynamicDictionary';\n\nconst DICTIONARIES_SUBDIR = 'json'; // Necessary to add a static first dir for Turbopack\nconst LOAD_CONTENT_MODULE = 'utils/loadContent';\n\n/**\n * Generates the content of the shared `_loadContent` module for fetch dictionaries,\n * written once per output directory. liveSyncURL and relativePrefix are baked in\n * as string literals since they are config-level constants for the whole build.\n */\nexport const generateFetchLoadContentModule = (\n  format: 'cjs' | 'esm',\n  liveSyncURL: string,\n  relativePrefix: string\n): string => {\n  if (format === 'esm') {\n    return (\n      `export const loadContent = async (key, locale) => {\\n` +\n      `  try {\\n` +\n      `    const res = await fetch(\\`${liveSyncURL}/dictionaries/\\${key}/\\${locale}\\`);\\n` +\n      `    return await res.json();\\n` +\n      `  } catch (_error) {\\n` +\n      `    const m = await import(\\`${relativePrefix}/${DICTIONARIES_SUBDIR}/\\${key}_\\${locale}.json\\`, { with: { type: 'json' } });\\n` +\n      `    return m.default || m;\\n` +\n      `  }\\n` +\n      `};\\n`\n    );\n  }\n  return (\n    `const loadContent = async (key, locale) => {\\n` +\n    `  try {\\n` +\n    `    const res = await fetch(\\`${liveSyncURL}/dictionaries/\\${key}/\\${locale}\\`);\\n` +\n    `    return await res.json();\\n` +\n    `  } catch (_error) {\\n` +\n    `    return Promise.resolve(require(\\`${relativePrefix}/dictionaries/\\${locale}_\\${key}.json\\`));\\n` +\n    `  }\\n` +\n    `};\\n` +\n    `module.exports = { loadContent };\\n`\n  );\n};\n\n/**\n * Generates the content of a fetch dictionary entry point file.\n * `loadContent` is imported from the shared `_loadContent` module.\n */\nexport const generateDictionaryEntryPoint = (\n  localizedDictionariesPathsRecord: LocalizedDictionaryResult,\n  key: string,\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n  const preamble =\n    format === 'esm'\n      ? `import { loadContent } from './${LOAD_CONTENT_MODULE}.${extension}';\\n\\n`\n      : `const { loadContent } = require('./${LOAD_CONTENT_MODULE}.${extension}');\\n\\n`;\n\n  return buildEntryPointContent(\n    preamble,\n    localizedDictionariesPathsRecord,\n    key,\n    format\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 { liveSyncURL } = configuration.editor;\n\n  // Compute relative path from the utils/ subdir (where loadContent lives) to dynamic dir\n  let relativePrefix = normalizePath(\n    relative(resolve(fetchDictionariesDir, 'utils'), dynamicDictionariesDir)\n  );\n  if (!relativePrefix.startsWith('.')) {\n    relativePrefix = `./${relativePrefix}`;\n  }\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(fetchDictionariesDir), { recursive: true });\n\n  // Write the shared loadContent module once per format\n  const utilsDir = resolve(fetchDictionariesDir, 'utils');\n  await mkdir(utilsDir, { recursive: true });\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, liveSyncURL, relativePrefix)\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(\n    Object.entries(dynamicDictionaries),\n    async ([key, localizedDictionariesPathsRecord]) => {\n      if (key === 'undefined') return;\n\n      await parallelize(formats, async (format) => {\n        const extension = format === 'cjs' ? 'cjs' : 'mjs';\n        const content = generateDictionaryEntryPoint(\n          localizedDictionariesPathsRecord,\n          key,\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\n  return resultDictionariesPaths;\n};\n"],"mappings":"ocAcA,MACM,EAAsB,oBAOf,GACX,EACA,EACA,IAEI,IAAW,MAEX;;gCAEiC,EAAY,yHAGb,EAAe,sGAOjD;;gCAEiC,EAAY,iIAGL,EAAe,0FAW9C,GACX,EACA,EACA,EAAwB,QACb,CACX,IAAM,EAAY,IAAW,MAAQ,MAAQ,MAM7C,OAAO,EAJL,IAAW,MACP,kCAAkC,EAAoB,GAAG,EAAU,QACnE,sCAAsC,EAAoB,GAAG,EAAU,SAI3E,EACA,EACA,EACD,EAmBU,EAAuB,MAClC,EACA,EACA,EAA6B,IACU,CACvC,GAAM,CAAE,uBAAsB,0BAA2B,EAAc,OACjE,CAAE,eAAgB,EAAc,OAGlC,EAAiB,EACnB,EAAS,EAAQ,EAAsB,QAAQ,CAAE,EAAuB,CACzE,CAqDD,OApDK,EAAe,WAAW,IAAI,GACjC,EAAiB,KAAK,KAIxB,MAAM,EAAM,EAAQ,EAAqB,CAAE,CAAE,UAAW,GAAM,CAAC,CAI/D,MAAM,EADW,EAAQ,EAAsB,QAAQ,CACjC,CAAE,UAAW,GAAM,CAAC,CAC1C,MAAM,EAAY,EAAS,KAAO,IAAW,CAC3C,IAAM,EAAY,IAAW,MAAQ,MAAQ,MAC7C,MAAM,EACJ,EAAQ,EAAsB,GAAG,EAAoB,GAAG,IAAY,CACpE,EAA+B,EAAQ,EAAa,EAAe,CACpE,CAAC,MAAO,GAAQ,CACf,QAAQ,MACN,wBAAwB,EAAa,EAAQ,EAAsB,GAAG,EAAoB,GAAG,IAAY,CAAC,CAAC,GAC3G,EACD,EACD,EACF,CAKF,MAAM,EACJ,OAAO,QAAQ,EAAoB,CACnC,MAAO,CAAC,EAAK,KAAsC,CAC7C,IAAQ,aAEZ,MAAM,EAAY,EAAS,KAAO,IAAW,CAC3C,IAAM,EAAY,IAAW,MAAQ,MAAQ,MACvC,EAAU,EACd,EACA,EACA,EACD,CAED,MAAM,EACJ,EAAQ,EAAsB,GAAG,EAAI,GAAG,IAAY,CACpD,EACD,CAAC,MAAO,GAAQ,CACf,QAAQ,MACN,wBAAwB,EAAa,EAAQ,EAAsB,GAAG,EAAI,GAAG,IAAY,CAAC,CAAC,GAC3F,EACD,EACD,EACF,EAEL,CA3B0D,EAAE"}
+{"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(\\`\\${configuration.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 { configuration } 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 { configuration } = 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,yHAEgF,OAAO,gFAGxE,OAAO,mBAGtC,CACA,KAAK,MAAM,CAKiB;AAG/B,KAAI,WAAW,MACb,QACE,6FACkD,eAAe,GAAG,oBAAoB,GAAG,UAAU,QAClG,KAAK;AAGZ,QACE,oGACoD,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"}

package/dist/esm/buildIntlayerDictionary/writeMergedDictionary.mjs

@@ -1,2 +1,45 @@
-import{parallelize as e}from"../utils/parallelize.mjs";import{writeJsonIfChanged as t}from"../writeJsonIfChanged.mjs";import{mkdir as n}from"node:fs/promises";import{resolve as r}from"node:path";import{colorizePath as i}from"@intlayer/config/logger";import{mergeDictionaries as a,normalizeDictionaries as o}from"@intlayer/core/dictionaryManipulator";const s=async(s,c)=>{let{dictionariesDir:l}=c.system;await n(r(l),{recursive:!0});let u=await e(Object.entries(s),async([e,n])=>{if(e===`undefined`)return;let s=a(o(n.dictionaries,c)),u=r(l,`${e}.json`);return await t(u,s).catch(e=>{console.error(`Error creating merged ${i(u)}:`,e)}),[e,{dictionaryPath:u,dictionary:s}]});return Object.fromEntries(u.filter(Boolean))};export{s as writeMergedDictionaries};
+import { parallelize } from "../utils/parallelize.mjs";
+import { writeJsonIfChanged } from "../writeJsonIfChanged.mjs";
+import { mkdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import { colorizePath } from "@intlayer/config/logger";
+import { mergeDictionaries, normalizeDictionaries } from "@intlayer/core/dictionaryManipulator";
+
+//#region src/buildIntlayerDictionary/writeMergedDictionary.ts
+/**
+* Write the merged dictionaries to the dictionariesDir
+* @param groupedDictionaries - The grouped dictionaries
+* @param configuration - The configuration
+* @returns The merged dictionaries
+*
+* @example
+* ```ts
+* const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);
+* const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);
+* console.log(finalDictionaries);
+*
+* // .intlayer/dictionary/home.json
+* // { key: 'home', content: { ... } },
+* ```
+*/
+const writeMergedDictionaries = async (groupedDictionaries, configuration) => {
+	const { dictionariesDir } = configuration.system;
+	await mkdir(resolve(dictionariesDir), { recursive: true });
+	const results = await parallelize(Object.entries(groupedDictionaries), async ([key, dictionariesEntry]) => {
+		if (key === "undefined") return;
+		const mergedDictionary = mergeDictionaries(normalizeDictionaries(dictionariesEntry.dictionaries, configuration));
+		const resultFilePath = resolve(dictionariesDir, `${key}.json`);
+		await writeJsonIfChanged(resultFilePath, mergedDictionary).catch((err) => {
+			console.error(`Error creating merged ${colorizePath(resultFilePath)}:`, err);
+		});
+		return [key, {
+			dictionaryPath: resultFilePath,
+			dictionary: mergedDictionary
+		}];
+	});
+	return Object.fromEntries(results.filter(Boolean));
+};
+
+//#endregion
+export { writeMergedDictionaries };
 //# sourceMappingURL=writeMergedDictionary.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"writeMergedDictionary.mjs","names":[],"sources":["../../../src/buildIntlayerDictionary/writeMergedDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { colorizePath } from '@intlayer/config/logger';\nimport {\n  mergeDictionaries,\n  normalizeDictionaries,\n} from '@intlayer/core/dictionaryManipulator';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { parallelize } from '../utils/parallelize';\nimport { writeJsonIfChanged } from '../writeJsonIfChanged';\nimport type { UnmergedDictionaryOutput } from './writeUnmergedDictionary';\n\nexport type MergedDictionaryResult = {\n  dictionaryPath: string;\n  dictionary: Dictionary;\n};\n\nexport type MergedDictionaryOutput = Record<string, MergedDictionaryResult>;\n\n/**\n * Write the merged dictionaries to the dictionariesDir\n * @param groupedDictionaries - The grouped dictionaries\n * @param configuration - The configuration\n * @returns The merged dictionaries\n *\n * @example\n * ```ts\n * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);\n * const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);\n * console.log(finalDictionaries);\n *\n * // .intlayer/dictionary/home.json\n * // { key: 'home', content: { ... } },\n * ```\n */\nexport const writeMergedDictionaries = async (\n  groupedDictionaries: UnmergedDictionaryOutput,\n  configuration: IntlayerConfig\n): Promise<MergedDictionaryOutput> => {\n  const { dictionariesDir } = configuration.system;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(dictionariesDir), { recursive: true });\n\n  const results = await parallelize(\n    Object.entries(groupedDictionaries),\n    async ([key, dictionariesEntry]) => {\n      if (key === 'undefined') {\n        return undefined as unknown as readonly [\n          string,\n          MergedDictionaryResult,\n        ];\n      }\n\n      const normalizedDictionaries = normalizeDictionaries(\n        dictionariesEntry.dictionaries,\n        configuration\n      );\n\n      const mergedDictionary = mergeDictionaries(normalizedDictionaries);\n\n      const outputFileName = `${key}.json`;\n      const resultFilePath = resolve(dictionariesDir, outputFileName);\n\n      // Write the merged dictionary\n      await writeJsonIfChanged(resultFilePath, mergedDictionary).catch(\n        (err) => {\n          console.error(\n            `Error creating merged ${colorizePath(resultFilePath)}:`,\n            err\n          );\n        }\n      );\n\n      return [\n        key,\n        {\n          dictionaryPath: resultFilePath,\n          dictionary: mergedDictionary,\n        } as MergedDictionaryResult,\n      ] as const;\n    }\n  );\n\n  return Object.fromEntries(\n    results.filter(Boolean) as Array<readonly [string, MergedDictionaryResult]>\n  );\n};\n"],"mappings":"8VAoCA,MAAa,EAA0B,MACrC,EACA,IACoC,CACpC,GAAM,CAAE,mBAAoB,EAAc,OAG1C,MAAM,EAAM,EAAQ,EAAgB,CAAE,CAAE,UAAW,GAAM,CAAC,CAE1D,IAAM,EAAU,MAAM,EACpB,OAAO,QAAQ,EAAoB,CACnC,MAAO,CAAC,EAAK,KAAuB,CAClC,GAAI,IAAQ,YACV,OAWF,IAAM,EAAmB,EALM,EAC7B,EAAkB,aAClB,EACD,CAEiE,CAG5D,EAAiB,EAAQ,EADR,GAAG,EAAI,OACiC,CAY/D,OATA,MAAM,EAAmB,EAAgB,EAAiB,CAAC,MACxD,GAAQ,CACP,QAAQ,MACN,yBAAyB,EAAa,EAAe,CAAC,GACtD,EACD,EAEJ,CAEM,CACL,EACA,CACE,eAAgB,EAChB,WAAY,EACb,CACF,EAEJ,CAED,OAAO,OAAO,YACZ,EAAQ,OAAO,QAAQ,CACxB"}
+{"version":3,"file":"writeMergedDictionary.mjs","names":[],"sources":["../../../src/buildIntlayerDictionary/writeMergedDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { colorizePath } from '@intlayer/config/logger';\nimport {\n  mergeDictionaries,\n  normalizeDictionaries,\n} from '@intlayer/core/dictionaryManipulator';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { parallelize } from '../utils/parallelize';\nimport { writeJsonIfChanged } from '../writeJsonIfChanged';\nimport type { UnmergedDictionaryOutput } from './writeUnmergedDictionary';\n\nexport type MergedDictionaryResult = {\n  dictionaryPath: string;\n  dictionary: Dictionary;\n};\n\nexport type MergedDictionaryOutput = Record<string, MergedDictionaryResult>;\n\n/**\n * Write the merged dictionaries to the dictionariesDir\n * @param groupedDictionaries - The grouped dictionaries\n * @param configuration - The configuration\n * @returns The merged dictionaries\n *\n * @example\n * ```ts\n * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);\n * const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);\n * console.log(finalDictionaries);\n *\n * // .intlayer/dictionary/home.json\n * // { key: 'home', content: { ... } },\n * ```\n */\nexport const writeMergedDictionaries = async (\n  groupedDictionaries: UnmergedDictionaryOutput,\n  configuration: IntlayerConfig\n): Promise<MergedDictionaryOutput> => {\n  const { dictionariesDir } = configuration.system;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(dictionariesDir), { recursive: true });\n\n  const results = await parallelize(\n    Object.entries(groupedDictionaries),\n    async ([key, dictionariesEntry]) => {\n      if (key === 'undefined') {\n        return undefined as unknown as readonly [\n          string,\n          MergedDictionaryResult,\n        ];\n      }\n\n      const normalizedDictionaries = normalizeDictionaries(\n        dictionariesEntry.dictionaries,\n        configuration\n      );\n\n      const mergedDictionary = mergeDictionaries(normalizedDictionaries);\n\n      const outputFileName = `${key}.json`;\n      const resultFilePath = resolve(dictionariesDir, outputFileName);\n\n      // Write the merged dictionary\n      await writeJsonIfChanged(resultFilePath, mergedDictionary).catch(\n        (err) => {\n          console.error(\n            `Error creating merged ${colorizePath(resultFilePath)}:`,\n            err\n          );\n        }\n      );\n\n      return [\n        key,\n        {\n          dictionaryPath: resultFilePath,\n          dictionary: mergedDictionary,\n        } as MergedDictionaryResult,\n      ] as const;\n    }\n  );\n\n  return Object.fromEntries(\n    results.filter(Boolean) as Array<readonly [string, MergedDictionaryResult]>\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAoCA,MAAa,0BAA0B,OACrC,qBACA,kBACoC;CACpC,MAAM,EAAE,oBAAoB,cAAc;AAG1C,OAAM,MAAM,QAAQ,gBAAgB,EAAE,EAAE,WAAW,MAAM,CAAC;CAE1D,MAAM,UAAU,MAAM,YACpB,OAAO,QAAQ,oBAAoB,EACnC,OAAO,CAAC,KAAK,uBAAuB;AAClC,MAAI,QAAQ,YACV;EAWF,MAAM,mBAAmB,kBALM,sBAC7B,kBAAkB,cAClB,cACD,CAEiE;EAGlE,MAAM,iBAAiB,QAAQ,iBADR,GAAG,IAAI,OACiC;AAG/D,QAAM,mBAAmB,gBAAgB,iBAAiB,CAAC,OACxD,QAAQ;AACP,WAAQ,MACN,yBAAyB,aAAa,eAAe,CAAC,IACtD,IACD;IAEJ;AAED,SAAO,CACL,KACA;GACE,gBAAgB;GAChB,YAAY;GACb,CACF;GAEJ;AAED,QAAO,OAAO,YACZ,QAAQ,OAAO,QAAQ,CACxB"}

package/dist/esm/buildIntlayerDictionary/writeRemoteDictionary.mjs

@@ -1,2 +1,49 @@
-import{parallelize as e}from"../utils/parallelize.mjs";import{writeJsonIfChanged as t}from"../writeJsonIfChanged.mjs";import{filterInvalidDictionaries as n}from"../filterInvalidDictionaries.mjs";import{groupDictionariesByKey as r}from"./writeUnmergedDictionary.mjs";import{formatDistantDictionaries as i}from"../loadDictionaries/loadRemoteDictionaries.mjs";import{mkdir as a}from"node:fs/promises";import{resolve as o}from"node:path";import{colorizePath as s,x as c}from"@intlayer/config/logger";import{orderDictionaries as l}from"@intlayer/core/dictionaryManipulator";const u=async(u,d)=>{let{remoteDictionariesDir:f}=d.system;await a(o(f),{recursive:!0});let p=r(n(u,d)),m=await e(Object.entries(p),async([e,n])=>{if(e===`undefined`)return;let r=l(i(n),d),a=o(f,`${e}.json`);return await t(a,r).catch(e=>{console.error(`${c} Error creating unmerged ${s(a)}:`,e)}),[e,{dictionaryPath:a,dictionaries:n}]});return Object.fromEntries(m.filter(Boolean))};export{u as writeRemoteDictionary};
+import { parallelize } from "../utils/parallelize.mjs";
+import { writeJsonIfChanged } from "../writeJsonIfChanged.mjs";
+import { filterInvalidDictionaries } from "../filterInvalidDictionaries.mjs";
+import { groupDictionariesByKey } from "./writeUnmergedDictionary.mjs";
+import { formatDistantDictionaries } from "../loadDictionaries/loadRemoteDictionaries.mjs";
+import { mkdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import { colorizePath, x } from "@intlayer/config/logger";
+import { orderDictionaries } from "@intlayer/core/dictionaryManipulator";
+
+//#region src/buildIntlayerDictionary/writeRemoteDictionary.ts
+/**
+* Write the localized dictionaries to the dictionariesDir
+* @param mergedDictionaries - The merged dictionaries
+* @param configuration - The configuration
+* @returns The final dictionaries
+*
+* @example
+* ```ts
+* const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);
+* const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);
+* console.log(finalDictionaries);
+*
+* // .intlayer/fetch_dictionaries/home.json
+* // { key: 'home', content: { ... } },
+* ```
+*/
+const writeRemoteDictionary = async (remoteDictionaries, configuration) => {
+	const { remoteDictionariesDir } = configuration.system;
+	await mkdir(resolve(remoteDictionariesDir), { recursive: true });
+	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 unmergedFilePath = resolve(remoteDictionariesDir, `${key}.json`);
+		await writeJsonIfChanged(unmergedFilePath, orderedDictionaries).catch((err) => {
+			console.error(`${x} Error creating unmerged ${colorizePath(unmergedFilePath)}:`, err);
+		});
+		return [key, {
+			dictionaryPath: unmergedFilePath,
+			dictionaries
+		}];
+	});
+	return Object.fromEntries(results.filter(Boolean));
+};
+
+//#endregion
+export { writeRemoteDictionary };
 //# sourceMappingURL=writeRemoteDictionary.mjs.map

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":"yjBAsCA,MAAa,EAAwB,MACnC,EACA,IACoC,CACpC,GAAM,CAAE,yBAA0B,EAAc,OAGhD,MAAM,EAAM,EAAQ,EAAsB,CAAE,CAAE,UAAW,GAAM,CAAC,CAQhE,IAAM,EAAsB,EANC,EAC3B,EACA,EACD,CAGuE,CAGlE,EAAU,MAAM,EACpB,OAAO,QAAQ,EAAoB,CACnC,MAAO,CAAC,EAAK,KAAkB,CAC7B,GAAI,IAAQ,YACV,OAQF,IAAM,EAAsB,EAFE,EAA0B,EAAa,CAInE,EACD,CAGK,EAAmB,EAAQ,EADV,GAAG,EAAI,OACyC,CAYvE,OATA,MAAM,EAAmB,EAAkB,EAAoB,CAAC,MAC7D,GAAQ,CACP,QAAQ,MACN,GAAG,EAAE,2BAA2B,EAAa,EAAiB,CAAC,GAC/D,EACD,EAEJ,CAEM,CACL,EACA,CACE,eAAgB,EAChB,eACD,CACF,EAEJ,CAED,OAAO,OAAO,YACZ,EAAQ,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(\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"}

package/dist/esm/buildIntlayerDictionary/writeUnmergedDictionary.mjs

@@ -1,2 +1,57 @@
-import{parallelize as e}from"../utils/parallelize.mjs";import{writeJsonIfChanged as t}from"../writeJsonIfChanged.mjs";import{filterInvalidDictionaries as n}from"../filterInvalidDictionaries.mjs";import{mkdir as r}from"node:fs/promises";import{resolve as i}from"node:path";import{colorizePath as a,x as o}from"@intlayer/config/logger";import{orderDictionaries as s}from"@intlayer/core/dictionaryManipulator";const c=e=>e.reduce((e,t)=>{let n=t.key;return e[n]||(e[n]=[]),e[n].push(t),e},{}),l=async(l,u,d)=>{let{unmergedDictionariesDir:f}=u.system;await r(i(f),{recursive:!0});let p=c(n(l,u,{checkSchema:!0})),m=await e(Object.entries(p),async([e,n])=>{if(e===`undefined`)return;let r=s(n,u),c=i(f,`${e}.json`);return(u.editor.enabled||d===`dev`)&&await t(c,r).catch(e=>{console.error(`${o} Error creating unmerged ${a(c)}:`,e)}),[e,{dictionaryPath:c,dictionaries:n}]});return Object.fromEntries(m.filter(Boolean))};export{c as groupDictionariesByKey,l as writeUnmergedDictionaries};
+import { parallelize } from "../utils/parallelize.mjs";
+import { writeJsonIfChanged } from "../writeJsonIfChanged.mjs";
+import { filterInvalidDictionaries } from "../filterInvalidDictionaries.mjs";
+import { mkdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import { colorizePath, x } from "@intlayer/config/logger";
+import { orderDictionaries } from "@intlayer/core/dictionaryManipulator";
+
+//#region src/buildIntlayerDictionary/writeUnmergedDictionary.ts
+const groupDictionariesByKey = (dictionaries) => dictionaries.reduce((acc, dictionary) => {
+	const key = dictionary.key;
+	if (!acc[key]) acc[key] = [];
+	acc[key].push(dictionary);
+	return acc;
+}, {});
+/**
+* Write the unmerged dictionaries to the unmergedDictionariesDir
+* @param dictionaries - The dictionaries to write
+* @param configuration - The configuration
+* @returns The grouped dictionaries
+*
+* @example
+* ```ts
+* const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);
+* console.log(unmergedDictionaries);
+*
+* // .intlayer/unmerged_dictionaries/home.json
+* // {
+* //   [
+* //     { key: 'home', content: { ... } },
+* //     { key: 'home', content: { ... } },
+* //   ],
+* // }
+* ```
+*/
+const writeUnmergedDictionaries = async (dictionaries, configuration, env) => {
+	const { unmergedDictionariesDir } = configuration.system;
+	await mkdir(resolve(unmergedDictionariesDir), { recursive: true });
+	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 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);
+		});
+		return [key, {
+			dictionaryPath: unmergedFilePath,
+			dictionaries
+		}];
+	});
+	return Object.fromEntries(results.filter(Boolean));
+};
+
+//#endregion
+export { groupDictionariesByKey, writeUnmergedDictionaries };
 //# sourceMappingURL=writeUnmergedDictionary.mjs.map

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":"uZAUA,MAAa,EACX,GAEA,EAAa,QACV,EAAK,IAAe,CACnB,IAAM,EAAM,EAAW,IAKvB,OAJK,EAAI,KACP,EAAI,GAAO,EAAE,EAEf,EAAI,GAAK,KAAK,EAAW,CAClB,GAET,EAAE,CACH,CAgCU,EAA4B,MACvC,EACA,EACA,IACsC,CACtC,GAAM,CAAE,2BAA4B,EAAc,OAGlD,MAAM,EAAM,EAAQ,EAAwB,CAAE,CAAE,UAAW,GAAM,CAAC,CASlE,IAAM,EAAsB,EAPC,EAC3B,EACA,EACA,CAAE,YAAa,GAAM,CACtB,CAGuE,CAElE,EAAU,MAAM,EACpB,OAAO,QAAQ,EAAoB,CACnC,MAAO,CAAC,EAAK,KAAkB,CAC7B,GAAI,IAAQ,YACV,OAMF,IAAM,EAAsB,EAC1B,EACA,EACD,CAGK,EAAmB,EAAQ,EADV,GAAG,EAAI,OAC2C,CAiBzE,OAXI,EAAc,OAAO,SAAW,IAAQ,QAC1C,MAAM,EAAmB,EAAkB,EAAoB,CAAC,MAC7D,GAAQ,CACP,QAAQ,MACN,GAAG,EAAE,2BAA2B,EAAa,EAAiB,CAAC,GAC/D,EACD,EAEJ,CAGI,CACL,EACA,CACE,eAAgB,EACF,eACf,CACF,EAEJ,CAED,OAAO,OAAO,YACZ,EAAQ,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(\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"}

package/dist/esm/cleanOutputDir.mjs

@@ -1,2 +1,29 @@
-import{rm as e}from"node:fs/promises";import{getAppLogger as t}from"@intlayer/config/logger";import{existsSync as n}from"node:fs";const r=async r=>{let{dictionariesDir:i,unmergedDictionariesDir:a,dynamicDictionariesDir:o,remoteDictionariesDir:s,fetchDictionariesDir:c,mainDir:l,typesDir:u,configDir:d,cacheDir:f}=r.system,p=t(r),m=[i,a,o,s,c,l,u,d,f];await Promise.all(m.filter(e=>n(e)).map(t=>e(t,{recursive:!0,force:!0}))),p(`Output directory cleaned`,{isVerbose:!0})};export{r as cleanOutputDir};
+import { rm } from "node:fs/promises";
+import { getAppLogger } from "@intlayer/config/logger";
+import { existsSync } from "node:fs";
+
+//#region src/cleanOutputDir.ts
+const cleanOutputDir = async (configuration) => {
+	const { dictionariesDir, unmergedDictionariesDir, dynamicDictionariesDir, remoteDictionariesDir, fetchDictionariesDir, mainDir, typesDir, configDir, cacheDir } = configuration.system;
+	const appLogger = getAppLogger(configuration);
+	const directoriesToClean = [
+		dictionariesDir,
+		unmergedDictionariesDir,
+		dynamicDictionariesDir,
+		remoteDictionariesDir,
+		fetchDictionariesDir,
+		mainDir,
+		typesDir,
+		configDir,
+		cacheDir
+	];
+	await Promise.all(directoriesToClean.filter((dir) => existsSync(dir)).map((dir) => rm(dir, {
+		recursive: true,
+		force: true
+	})));
+	appLogger("Output directory cleaned", { isVerbose: true });
+};
+
+//#endregion
+export { cleanOutputDir };
 //# sourceMappingURL=cleanOutputDir.mjs.map

package/dist/esm/cleanOutputDir.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"cleanOutputDir.mjs","names":[],"sources":["../../src/cleanOutputDir.ts"],"sourcesContent":["import { existsSync } from 'node:fs';\nimport { rm } from 'node:fs/promises';\nimport { getAppLogger } from '@intlayer/config/logger';\nimport type { IntlayerConfig } from '@intlayer/types/config';\n\nexport const cleanOutputDir = async (configuration: IntlayerConfig) => {\n  const {\n    dictionariesDir,\n    unmergedDictionariesDir,\n    dynamicDictionariesDir,\n    remoteDictionariesDir,\n    fetchDictionariesDir,\n    mainDir,\n    typesDir,\n    configDir,\n    cacheDir,\n  } = configuration.system;\n\n  const appLogger = getAppLogger(configuration);\n\n  const directoriesToClean: string[] = [\n    dictionariesDir, // Merged dictionaries\n    unmergedDictionariesDir, // Unmerged dictionaries\n    dynamicDictionariesDir, // Dynamic dictionaries\n    remoteDictionariesDir, // Remote dictionaries\n    fetchDictionariesDir, // Fetch dictionaries\n    mainDir, // Main files\n    typesDir, // Types\n    configDir, // Configuration\n    cacheDir, // Cache\n  ];\n\n  // Execute all deletions in parallel\n  await Promise.all(\n    directoriesToClean\n      .filter((dir) => existsSync(dir))\n      .map((dir) => rm(dir, { recursive: true, force: true }))\n  );\n\n  appLogger('Output directory cleaned', {\n    isVerbose: true,\n  });\n};\n"],"mappings":"kIAKA,MAAa,EAAiB,KAAO,IAAkC,CACrE,GAAM,CACJ,kBACA,0BACA,yBACA,wBACA,uBACA,UACA,WACA,YACA,YACE,EAAc,OAEZ,EAAY,EAAa,EAAc,CAEvC,EAA+B,CACnC,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACD,CAGD,MAAM,QAAQ,IACZ,EACG,OAAQ,GAAQ,EAAW,EAAI,CAAC,CAChC,IAAK,GAAQ,EAAG,EAAK,CAAE,UAAW,GAAM,MAAO,GAAM,CAAC,CAAC,CAC3D,CAED,EAAU,2BAA4B,CACpC,UAAW,GACZ,CAAC"}
+{"version":3,"file":"cleanOutputDir.mjs","names":[],"sources":["../../src/cleanOutputDir.ts"],"sourcesContent":["import { existsSync } from 'node:fs';\nimport { rm } from 'node:fs/promises';\nimport { getAppLogger } from '@intlayer/config/logger';\nimport type { IntlayerConfig } from '@intlayer/types/config';\n\nexport const cleanOutputDir = async (configuration: IntlayerConfig) => {\n  const {\n    dictionariesDir,\n    unmergedDictionariesDir,\n    dynamicDictionariesDir,\n    remoteDictionariesDir,\n    fetchDictionariesDir,\n    mainDir,\n    typesDir,\n    configDir,\n    cacheDir,\n  } = configuration.system;\n\n  const appLogger = getAppLogger(configuration);\n\n  const directoriesToClean: string[] = [\n    dictionariesDir, // Merged dictionaries\n    unmergedDictionariesDir, // Unmerged dictionaries\n    dynamicDictionariesDir, // Dynamic dictionaries\n    remoteDictionariesDir, // Remote dictionaries\n    fetchDictionariesDir, // Fetch dictionaries\n    mainDir, // Main files\n    typesDir, // Types\n    configDir, // Configuration\n    cacheDir, // Cache\n  ];\n\n  // Execute all deletions in parallel\n  await Promise.all(\n    directoriesToClean\n      .filter((dir) => existsSync(dir))\n      .map((dir) => rm(dir, { recursive: true, force: true }))\n  );\n\n  appLogger('Output directory cleaned', {\n    isVerbose: true,\n  });\n};\n"],"mappings":";;;;;AAKA,MAAa,iBAAiB,OAAO,kBAAkC;CACrE,MAAM,EACJ,iBACA,yBACA,wBACA,uBACA,sBACA,SACA,UACA,WACA,aACE,cAAc;CAElB,MAAM,YAAY,aAAa,cAAc;CAE7C,MAAM,qBAA+B;EACnC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD;AAGD,OAAM,QAAQ,IACZ,mBACG,QAAQ,QAAQ,WAAW,IAAI,CAAC,CAChC,KAAK,QAAQ,GAAG,KAAK;EAAE,WAAW;EAAM,OAAO;EAAM,CAAC,CAAC,CAC3D;AAED,WAAU,4BAA4B,EACpC,WAAW,MACZ,CAAC"}

package/dist/esm/cleanRemovedContentDeclaration.mjs

@@ -1,2 +1,95 @@
-import{createDictionaryEntryPoint as e}from"./createDictionaryEntryPoint/createDictionaryEntryPoint.mjs";import{writeJsonIfChanged as t}from"./writeJsonIfChanged.mjs";import{readFile as n,rm as r}from"node:fs/promises";import{join as i,normalize as a,relative as o}from"node:path";import{normalizePath as s}from"@intlayer/config/client";import{colorizeKey as c,colorizePath as l,getAppLogger as u}from"@intlayer/config/logger";import{getDictionaries as d}from"@intlayer/dictionaries-entry";import{getUnmergedDictionaries as f}from"@intlayer/unmerged-dictionaries-entry";import p from"fast-glob";const m=async(m,h,g)=>{let _=u(g),v=f(g),y=g.system.baseDir,b=o(y,m),x=Object.values(v).flat().filter(e=>e.filePath===b&&!h.includes(e.key)).filter((e,t,n)=>t===n.findIndex(t=>t.key===e.key)),S=[],C=[],w=[];await Promise.all(x.map(async e=>{let r=a(i(g.system.unmergedDictionariesDir,`${e.key}.json`));try{let i=await n(r,`utf8`),a=JSON.parse(i);a.length===1?a[0].filePath===b&&(_(`Removing outdated dictionary ${c(e.key)}`,{isVerbose:!0}),C.push(r),w.push(e.key)):(await t(r,a.filter(e=>e.filePath!==b)),S.push(e.localId))}catch(t){t.code===`ENOENT`&&(w.includes(e.key)||w.push(e.key))}}));let T=d(g),E=(Object.values(T)?.filter(e=>!h.includes(e.key)&&e.localIds?.length===1&&e.localIds[0].endsWith(`::local::${b}`))).filter((e,t,n)=>t===n.findIndex(t=>t.key===e.key));return await Promise.all(E.map(async e=>{let r=a(i(g.system.dictionariesDir,`${e.key}.json`));try{let o=await n(r,`utf8`),l=JSON.parse(o);if(l.localIds?.length===1){if(l.localIds[0].endsWith(`::local::${b}`)){_(`Removing outdated unmerged dictionary ${c(e.key)}`,{isVerbose:!0}),C.push(r);let t=a(i(g.system.typesDir,`${e.key}.ts`));C.push(t);let n=await p(s(i(g.system.dynamicDictionariesDir,`${e.key}.*`)),{absolute:!0});C.push(...n),w.includes(e.key)||w.push(e.key)}}else{let e=l.localIds?.filter(e=>!e.endsWith(`::local::${b}`));await t(r,{...l,localIds:e})}}catch(t){if(t.code===`ENOENT`){w.includes(e.key)||w.push(e.key);let t=a(i(g.system.typesDir,`${e.key}.ts`));C.push(t)}}})),(C.length>0||w.length>0)&&(await e(g,{excludeKeys:w}),C.length>0&&await Promise.all(C.map(async e=>{let t=o(y,e);try{await r(e,{force:!0}),_(`Deleted artifact: ${l(t)}`,{isVerbose:!0})}catch{_(`Error while removing file ${l(t)}`,{isVerbose:!0})}}))),{changedDictionariesLocalIds:S,excludeKeys:w,hasRebuilt:C.length>0||w.length>0}};export{m as cleanRemovedContentDeclaration};
+import { createDictionaryEntryPoint } from "./createDictionaryEntryPoint/createDictionaryEntryPoint.mjs";
+import { writeJsonIfChanged } from "./writeJsonIfChanged.mjs";
+import { readFile, rm } from "node:fs/promises";
+import { join, normalize, relative } from "node:path";
+import { normalizePath } from "@intlayer/config/client";
+import { colorizeKey, colorizePath, getAppLogger } from "@intlayer/config/logger";
+import { getDictionaries } from "@intlayer/dictionaries-entry";
+import { getUnmergedDictionaries } from "@intlayer/unmerged-dictionaries-entry";
+import fg from "fast-glob";
+
+//#region src/cleanRemovedContentDeclaration.ts
+const cleanRemovedContentDeclaration = async (filePath, keysToKeep, configuration) => {
+	const appLogger = getAppLogger(configuration);
+	const unmergedDictionaries = getUnmergedDictionaries(configuration);
+	const baseDir = configuration.system.baseDir;
+	const relativeFilePath = relative(baseDir, filePath);
+	const uniqueUnmergedDictionaries = Object.values(unmergedDictionaries).flat().filter((dictionary) => dictionary.filePath === relativeFilePath && !keysToKeep.includes(dictionary.key)).filter((dictionary, index, self) => index === self.findIndex((t) => t.key === dictionary.key));
+	const changedDictionariesLocalIds = [];
+	const filesToRemove = [];
+	const excludeKeys = [];
+	await Promise.all(uniqueUnmergedDictionaries.map(async (dictionary) => {
+		const unmergedFilePath = normalize(join(configuration.system.unmergedDictionariesDir, `${dictionary.key}.json`));
+		try {
+			const jsonContent = await readFile(unmergedFilePath, "utf8");
+			const parsedContent = JSON.parse(jsonContent);
+			if (parsedContent.length === 1) {
+				if (parsedContent[0].filePath === relativeFilePath) {
+					appLogger(`Removing outdated dictionary ${colorizeKey(dictionary.key)}`, { isVerbose: true });
+					filesToRemove.push(unmergedFilePath);
+					excludeKeys.push(dictionary.key);
+				}
+			} else {
+				await writeJsonIfChanged(unmergedFilePath, parsedContent.filter((content) => content.filePath !== relativeFilePath));
+				changedDictionariesLocalIds.push(dictionary.localId);
+			}
+		} catch (error) {
+			if (error.code === "ENOENT") {
+				if (!excludeKeys.includes(dictionary.key)) excludeKeys.push(dictionary.key);
+			}
+		}
+	}));
+	const dictionaries = getDictionaries(configuration);
+	const uniqueMergedDictionaries = (Object.values(dictionaries)?.filter((dictionary) => !keysToKeep.includes(dictionary.key) && dictionary.localIds?.length === 1 && dictionary.localIds[0].endsWith(`::local::${relativeFilePath}`))).filter((dictionary, index, self) => index === self.findIndex((t) => t.key === dictionary.key));
+	await Promise.all(uniqueMergedDictionaries.map(async (dictionary) => {
+		const mergedFilePath = normalize(join(configuration.system.dictionariesDir, `${dictionary.key}.json`));
+		try {
+			const fileContent = await readFile(mergedFilePath, "utf8");
+			const parsedContent = JSON.parse(fileContent);
+			if (parsedContent.localIds?.length === 1) {
+				if (parsedContent.localIds[0].endsWith(`::local::${relativeFilePath}`)) {
+					appLogger(`Removing outdated unmerged dictionary ${colorizeKey(dictionary.key)}`, { isVerbose: true });
+					filesToRemove.push(mergedFilePath);
+					const typesFilePath = normalize(join(configuration.system.typesDir, `${dictionary.key}.ts`));
+					filesToRemove.push(typesFilePath);
+					const dynamicFiles = await fg(normalizePath(join(configuration.system.dynamicDictionariesDir, `${dictionary.key}.*`)), { absolute: true });
+					filesToRemove.push(...dynamicFiles);
+					if (!excludeKeys.includes(dictionary.key)) excludeKeys.push(dictionary.key);
+				}
+			} else {
+				const localIds = parsedContent.localIds?.filter((localeId) => !localeId.endsWith(`::local::${relativeFilePath}`));
+				await writeJsonIfChanged(mergedFilePath, {
+					...parsedContent,
+					localIds
+				});
+			}
+		} catch (error) {
+			if (error.code === "ENOENT") {
+				if (!excludeKeys.includes(dictionary.key)) excludeKeys.push(dictionary.key);
+				const typesFilePath = normalize(join(configuration.system.typesDir, `${dictionary.key}.ts`));
+				filesToRemove.push(typesFilePath);
+			}
+		}
+	}));
+	if (filesToRemove.length > 0 || excludeKeys.length > 0) {
+		await createDictionaryEntryPoint(configuration, { excludeKeys });
+		if (filesToRemove.length > 0) await Promise.all(filesToRemove.map(async (path) => {
+			const relativePath = relative(baseDir, path);
+			try {
+				await rm(path, { force: true });
+				appLogger(`Deleted artifact: ${colorizePath(relativePath)}`, { isVerbose: true });
+			} catch {
+				appLogger(`Error while removing file ${colorizePath(relativePath)}`, { isVerbose: true });
+			}
+		}));
+	}
+	return {
+		changedDictionariesLocalIds,
+		excludeKeys,
+		hasRebuilt: filesToRemove.length > 0 || excludeKeys.length > 0
+	};
+};
+
+//#endregion
+export { cleanRemovedContentDeclaration };
 //# sourceMappingURL=cleanRemovedContentDeclaration.mjs.map

package/dist/esm/cleanRemovedContentDeclaration.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"cleanRemovedContentDeclaration.mjs","names":[],"sources":["../../src/cleanRemovedContentDeclaration.ts"],"sourcesContent":["import { readFile, rm } from 'node:fs/promises';\nimport { join, normalize, relative } from 'node:path';\nimport { normalizePath } from '@intlayer/config/client';\nimport {\n  colorizeKey,\n  colorizePath,\n  getAppLogger,\n} from '@intlayer/config/logger';\nimport { getDictionaries } from '@intlayer/dictionaries-entry';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { getUnmergedDictionaries } from '@intlayer/unmerged-dictionaries-entry';\nimport fg from 'fast-glob';\nimport { createDictionaryEntryPoint } from './createDictionaryEntryPoint';\nimport { writeJsonIfChanged } from './writeJsonIfChanged';\n\nexport const cleanRemovedContentDeclaration = async (\n  filePath: string,\n  keysToKeep: string[],\n  configuration: IntlayerConfig\n): Promise<{\n  changedDictionariesLocalIds: string[];\n  excludeKeys: string[];\n  hasRebuilt: boolean;\n}> => {\n  const appLogger = getAppLogger(configuration);\n\n  const unmergedDictionaries = getUnmergedDictionaries(configuration);\n\n  const baseDir = configuration.system.baseDir;\n\n  const relativeFilePath = relative(baseDir, filePath);\n  const flatUnmergedDictionaries = Object.values(unmergedDictionaries).flat();\n\n  const filteredUnmergedDictionaries = flatUnmergedDictionaries.filter(\n    (dictionary) =>\n      dictionary.filePath === relativeFilePath &&\n      !keysToKeep.includes(dictionary.key)\n  );\n\n  // Deduplicate dictionaries by key\n  const uniqueUnmergedDictionaries = filteredUnmergedDictionaries.filter(\n    (dictionary, index, self) =>\n      index === self.findIndex((t) => t.key === dictionary.key)\n  );\n\n  const changedDictionariesLocalIds: string[] = [];\n  const filesToRemove: string[] = [];\n  const excludeKeys: string[] = [];\n\n  // Identify Unmerged Dictionaries to remove or clean\n  await Promise.all(\n    uniqueUnmergedDictionaries.map(async (dictionary) => {\n      const unmergedFilePath = normalize(\n        join(\n          configuration.system.unmergedDictionariesDir,\n          `${dictionary.key}.json`\n        )\n      );\n\n      try {\n        const jsonContent = await readFile(unmergedFilePath, 'utf8');\n        const parsedContent = JSON.parse(jsonContent);\n\n        if (parsedContent.length === 1) {\n          if (parsedContent[0].filePath === relativeFilePath) {\n            appLogger(\n              `Removing outdated dictionary ${colorizeKey(dictionary.key)}`,\n              { isVerbose: true }\n            );\n            filesToRemove.push(unmergedFilePath);\n            excludeKeys.push(dictionary.key);\n          }\n        } else {\n          const filteredContent = parsedContent.filter(\n            (content: any) => content.filePath !== relativeFilePath\n          );\n          await writeJsonIfChanged(unmergedFilePath, filteredContent);\n          changedDictionariesLocalIds.push(dictionary.localId!);\n        }\n      } catch (error: any) {\n        if (error.code === 'ENOENT') {\n          if (!excludeKeys.includes(dictionary.key)) {\n            excludeKeys.push(dictionary.key);\n          }\n        }\n      }\n    })\n  );\n\n  const dictionaries = getDictionaries(configuration);\n  const flatDictionaries = Object.values(dictionaries) as Dictionary[];\n\n  const filteredMergedDictionaries = flatDictionaries?.filter(\n    (dictionary) =>\n      !keysToKeep.includes(dictionary.key) &&\n      dictionary.localIds?.length === 1 &&\n      (dictionary.localIds[0] as string).endsWith(\n        `::local::${relativeFilePath}`\n      )\n  );\n\n  const uniqueMergedDictionaries = filteredMergedDictionaries.filter(\n    (dictionary, index, self) =>\n      index === self.findIndex((t) => t.key === dictionary.key)\n  );\n\n  // Identify Merged Dictionaries, Types, and Dynamic Dictionaries to remove\n  await Promise.all(\n    uniqueMergedDictionaries.map(async (dictionary) => {\n      const mergedFilePath = normalize(\n        join(configuration.system.dictionariesDir, `${dictionary.key}.json`)\n      );\n\n      try {\n        const fileContent = await readFile(mergedFilePath, 'utf8');\n        const parsedContent = JSON.parse(fileContent) as Dictionary;\n\n        if (parsedContent.localIds?.length === 1) {\n          if (\n            parsedContent.localIds[0].endsWith(`::local::${relativeFilePath}`)\n          ) {\n            appLogger(\n              `Removing outdated unmerged dictionary ${colorizeKey(dictionary.key)}`,\n              { isVerbose: true }\n            );\n\n            // Mark JSON for removal\n            filesToRemove.push(mergedFilePath);\n\n            // Mark TS Types for removal\n            const typesFilePath = normalize(\n              join(configuration.system.typesDir, `${dictionary.key}.ts`)\n            );\n            filesToRemove.push(typesFilePath);\n\n            // Mark Dynamic Dictionaries for removal\n            // We use glob to catch the loader files (.cjs, .mjs) AND the split locale files (.en.json, etc.)\n            const dynamicFilesGlob = join(\n              configuration.system.dynamicDictionariesDir,\n              `${dictionary.key}.*`\n            );\n            const dynamicFiles = await fg(normalizePath(dynamicFilesGlob), {\n              absolute: true,\n            });\n            filesToRemove.push(...dynamicFiles);\n\n            if (!excludeKeys.includes(dictionary.key)) {\n              excludeKeys.push(dictionary.key);\n            }\n          }\n        } else {\n          const localIds = parsedContent.localIds?.filter(\n            (localeId) => !localeId.endsWith(`::local::${relativeFilePath}`)\n          ) as string[];\n          const newContent = { ...parsedContent, localIds };\n          await writeJsonIfChanged(mergedFilePath, newContent);\n        }\n      } catch (error: any) {\n        if (error.code === 'ENOENT') {\n          if (!excludeKeys.includes(dictionary.key)) {\n            excludeKeys.push(dictionary.key);\n          }\n          const typesFilePath = normalize(\n            join(configuration.system.typesDir, `${dictionary.key}.ts`)\n          );\n          filesToRemove.push(typesFilePath);\n        }\n      }\n    })\n  );\n\n  // Execute Cleanup\n  if (filesToRemove.length > 0 || excludeKeys.length > 0) {\n    // Update entry points (indexes) first so the app doesn't import dead files\n    await createDictionaryEntryPoint(configuration, { excludeKeys });\n\n    // Remove the files synchronously (awaited) immediately after.\n    if (filesToRemove.length > 0) {\n      await Promise.all(\n        filesToRemove.map(async (path) => {\n          const relativePath = relative(baseDir, path);\n          try {\n            await rm(path, { force: true });\n\n            appLogger(`Deleted artifact: ${colorizePath(relativePath)}`, {\n              isVerbose: true,\n            });\n          } catch {\n            appLogger(\n              `Error while removing file ${colorizePath(relativePath)}`,\n              {\n                isVerbose: true,\n              }\n            );\n          }\n        })\n      );\n    }\n  }\n\n  return {\n    changedDictionariesLocalIds,\n    excludeKeys,\n    hasRebuilt: filesToRemove.length > 0 || excludeKeys.length > 0,\n  };\n};\n"],"mappings":"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"}
+{"version":3,"file":"cleanRemovedContentDeclaration.mjs","names":[],"sources":["../../src/cleanRemovedContentDeclaration.ts"],"sourcesContent":["import { readFile, rm } from 'node:fs/promises';\nimport { join, normalize, relative } from 'node:path';\nimport { normalizePath } from '@intlayer/config/client';\nimport {\n  colorizeKey,\n  colorizePath,\n  getAppLogger,\n} from '@intlayer/config/logger';\nimport { getDictionaries } from '@intlayer/dictionaries-entry';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { getUnmergedDictionaries } from '@intlayer/unmerged-dictionaries-entry';\nimport fg from 'fast-glob';\nimport { createDictionaryEntryPoint } from './createDictionaryEntryPoint';\nimport { writeJsonIfChanged } from './writeJsonIfChanged';\n\nexport const cleanRemovedContentDeclaration = async (\n  filePath: string,\n  keysToKeep: string[],\n  configuration: IntlayerConfig\n): Promise<{\n  changedDictionariesLocalIds: string[];\n  excludeKeys: string[];\n  hasRebuilt: boolean;\n}> => {\n  const appLogger = getAppLogger(configuration);\n\n  const unmergedDictionaries = getUnmergedDictionaries(configuration);\n\n  const baseDir = configuration.system.baseDir;\n\n  const relativeFilePath = relative(baseDir, filePath);\n  const flatUnmergedDictionaries = Object.values(unmergedDictionaries).flat();\n\n  const filteredUnmergedDictionaries = flatUnmergedDictionaries.filter(\n    (dictionary) =>\n      dictionary.filePath === relativeFilePath &&\n      !keysToKeep.includes(dictionary.key)\n  );\n\n  // Deduplicate dictionaries by key\n  const uniqueUnmergedDictionaries = filteredUnmergedDictionaries.filter(\n    (dictionary, index, self) =>\n      index === self.findIndex((t) => t.key === dictionary.key)\n  );\n\n  const changedDictionariesLocalIds: string[] = [];\n  const filesToRemove: string[] = [];\n  const excludeKeys: string[] = [];\n\n  // Identify Unmerged Dictionaries to remove or clean\n  await Promise.all(\n    uniqueUnmergedDictionaries.map(async (dictionary) => {\n      const unmergedFilePath = normalize(\n        join(\n          configuration.system.unmergedDictionariesDir,\n          `${dictionary.key}.json`\n        )\n      );\n\n      try {\n        const jsonContent = await readFile(unmergedFilePath, 'utf8');\n        const parsedContent = JSON.parse(jsonContent);\n\n        if (parsedContent.length === 1) {\n          if (parsedContent[0].filePath === relativeFilePath) {\n            appLogger(\n              `Removing outdated dictionary ${colorizeKey(dictionary.key)}`,\n              { isVerbose: true }\n            );\n            filesToRemove.push(unmergedFilePath);\n            excludeKeys.push(dictionary.key);\n          }\n        } else {\n          const filteredContent = parsedContent.filter(\n            (content: any) => content.filePath !== relativeFilePath\n          );\n          await writeJsonIfChanged(unmergedFilePath, filteredContent);\n          changedDictionariesLocalIds.push(dictionary.localId!);\n        }\n      } catch (error: any) {\n        if (error.code === 'ENOENT') {\n          if (!excludeKeys.includes(dictionary.key)) {\n            excludeKeys.push(dictionary.key);\n          }\n        }\n      }\n    })\n  );\n\n  const dictionaries = getDictionaries(configuration);\n  const flatDictionaries = Object.values(dictionaries) as Dictionary[];\n\n  const filteredMergedDictionaries = flatDictionaries?.filter(\n    (dictionary) =>\n      !keysToKeep.includes(dictionary.key) &&\n      dictionary.localIds?.length === 1 &&\n      (dictionary.localIds[0] as string).endsWith(\n        `::local::${relativeFilePath}`\n      )\n  );\n\n  const uniqueMergedDictionaries = filteredMergedDictionaries.filter(\n    (dictionary, index, self) =>\n      index === self.findIndex((t) => t.key === dictionary.key)\n  );\n\n  // Identify Merged Dictionaries, Types, and Dynamic Dictionaries to remove\n  await Promise.all(\n    uniqueMergedDictionaries.map(async (dictionary) => {\n      const mergedFilePath = normalize(\n        join(configuration.system.dictionariesDir, `${dictionary.key}.json`)\n      );\n\n      try {\n        const fileContent = await readFile(mergedFilePath, 'utf8');\n        const parsedContent = JSON.parse(fileContent) as Dictionary;\n\n        if (parsedContent.localIds?.length === 1) {\n          if (\n            parsedContent.localIds[0].endsWith(`::local::${relativeFilePath}`)\n          ) {\n            appLogger(\n              `Removing outdated unmerged dictionary ${colorizeKey(dictionary.key)}`,\n              { isVerbose: true }\n            );\n\n            // Mark JSON for removal\n            filesToRemove.push(mergedFilePath);\n\n            // Mark TS Types for removal\n            const typesFilePath = normalize(\n              join(configuration.system.typesDir, `${dictionary.key}.ts`)\n            );\n            filesToRemove.push(typesFilePath);\n\n            // Mark Dynamic Dictionaries for removal\n            // We use glob to catch the loader files (.cjs, .mjs) AND the split locale files (.en.json, etc.)\n            const dynamicFilesGlob = join(\n              configuration.system.dynamicDictionariesDir,\n              `${dictionary.key}.*`\n            );\n            const dynamicFiles = await fg(normalizePath(dynamicFilesGlob), {\n              absolute: true,\n            });\n            filesToRemove.push(...dynamicFiles);\n\n            if (!excludeKeys.includes(dictionary.key)) {\n              excludeKeys.push(dictionary.key);\n            }\n          }\n        } else {\n          const localIds = parsedContent.localIds?.filter(\n            (localeId) => !localeId.endsWith(`::local::${relativeFilePath}`)\n          ) as string[];\n          const newContent = { ...parsedContent, localIds };\n          await writeJsonIfChanged(mergedFilePath, newContent);\n        }\n      } catch (error: any) {\n        if (error.code === 'ENOENT') {\n          if (!excludeKeys.includes(dictionary.key)) {\n            excludeKeys.push(dictionary.key);\n          }\n          const typesFilePath = normalize(\n            join(configuration.system.typesDir, `${dictionary.key}.ts`)\n          );\n          filesToRemove.push(typesFilePath);\n        }\n      }\n    })\n  );\n\n  // Execute Cleanup\n  if (filesToRemove.length > 0 || excludeKeys.length > 0) {\n    // Update entry points (indexes) first so the app doesn't import dead files\n    await createDictionaryEntryPoint(configuration, { excludeKeys });\n\n    // Remove the files synchronously (awaited) immediately after.\n    if (filesToRemove.length > 0) {\n      await Promise.all(\n        filesToRemove.map(async (path) => {\n          const relativePath = relative(baseDir, path);\n          try {\n            await rm(path, { force: true });\n\n            appLogger(`Deleted artifact: ${colorizePath(relativePath)}`, {\n              isVerbose: true,\n            });\n          } catch {\n            appLogger(\n              `Error while removing file ${colorizePath(relativePath)}`,\n              {\n                isVerbose: true,\n              }\n            );\n          }\n        })\n      );\n    }\n  }\n\n  return {\n    changedDictionariesLocalIds,\n    excludeKeys,\n    hasRebuilt: filesToRemove.length > 0 || excludeKeys.length > 0,\n  };\n};\n"],"mappings":"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"}

package/dist/esm/cli.mjs

@@ -1 +1,15 @@
-import{listProjects as e}from"./listProjects.mjs";import{listDictionaries as t,listDictionariesWithStats as n}from"./listDictionariesPath.mjs";import{detectExportedComponentName as r}from"./writeContentDeclaration/detectExportedComponentName.mjs";import{transformJSFile as i}from"./writeContentDeclaration/transformJSFile.mjs";import{detectFormatCommand as a}from"./detectFormatCommand.mjs";import{getContentDeclarationFileTemplate as o}from"./getContentDeclarationFileTemplate/getContentDeclarationFileTemplate.mjs";import{writeJSFile as s}from"./writeContentDeclaration/writeJSFile.mjs";import{writeContentDeclaration as c}from"./writeContentDeclaration/writeContentDeclaration.mjs";import"./writeContentDeclaration/index.mjs";import"./getContentDeclarationFileTemplate/index.mjs";import"./_utils_asset-4w8dPH9r.mjs";import{initIntlayer as l}from"./init/index.mjs";import{PLATFORMS as u,PLATFORMS_METADATA as d,SKILLS as f,SKILLS_METADATA as p,getInitialSkills as m,installSkills as h}from"./installSkills/index.mjs";import{installMCP as g}from"./installMCP/installMCP.mjs";import{listGitFiles as _,listGitLines as v}from"./listGitFiles.mjs";import{logConfigDetails as y}from"./logConfigDetails.mjs";export{u as PLATFORMS,d as PLATFORMS_METADATA,f as SKILLS,p as SKILLS_METADATA,r as detectExportedComponentName,a as detectFormatCommand,o as getContentDeclarationFileTemplate,m as getInitialSkills,l as initIntlayer,g as installMCP,h as installSkills,t as listDictionaries,n as listDictionariesWithStats,_ as listGitFiles,v as listGitLines,e as listProjects,y as logConfigDetails,i as transformJSFile,c as writeContentDeclaration,s as writeJSFile};
+import { listProjects } from "./listProjects.mjs";
+import { listDictionaries, listDictionariesWithStats } from "./listDictionariesPath.mjs";
+import { detectExportedComponentName } from "./writeContentDeclaration/detectExportedComponentName.mjs";
+import { transformJSFile } from "./writeContentDeclaration/transformJSFile.mjs";
+import { detectFormatCommand } from "./detectFormatCommand.mjs";
+import { getContentDeclarationFileTemplate } from "./getContentDeclarationFileTemplate/getContentDeclarationFileTemplate.mjs";
+import { writeJSFile } from "./writeContentDeclaration/writeJSFile.mjs";
+import { writeContentDeclaration } from "./writeContentDeclaration/writeContentDeclaration.mjs";
+import { initIntlayer } from "./init/index.mjs";
+import { PLATFORMS, PLATFORMS_METADATA, SKILLS, SKILLS_METADATA, getInitialSkills, installSkills } from "./installSkills/index.mjs";
+import { installMCP } from "./installMCP/installMCP.mjs";
+import { listGitFiles, listGitLines } from "./listGitFiles.mjs";
+import { logConfigDetails } from "./logConfigDetails.mjs";
+
+export { PLATFORMS, PLATFORMS_METADATA, SKILLS, SKILLS_METADATA, detectExportedComponentName, detectFormatCommand, getContentDeclarationFileTemplate, getInitialSkills, initIntlayer, installMCP, installSkills, listDictionaries, listDictionariesWithStats, listGitFiles, listGitLines, listProjects, logConfigDetails, transformJSFile, writeContentDeclaration, writeJSFile };

package/dist/esm/createDictionaryEntryPoint/createDictionaryEntryPoint.mjs

@@ -1,2 +1,69 @@
-import{parallelize as e}from"../utils/parallelize.mjs";import{writeFileIfChanged as t}from"../writeFileIfChanged.mjs";import{generateDictionaryListContent as n}from"./generateDictionaryListContent.mjs";import{getBuiltDictionariesPath as r}from"./getBuiltDictionariesPath.mjs";import{getBuiltDynamicDictionariesPath as i}from"./getBuiltDynamicDictionariesPath.mjs";import{getBuiltFetchDictionariesPath as a}from"./getBuiltFetchDictionariesPath.mjs";import{getBuiltRemoteDictionariesPath as o}from"./getBuiltRemoteDictionariesPath.mjs";import{getBuiltUnmergedDictionariesPath as s}from"./getBuiltUnmergedDictionariesPath.mjs";import{mkdir as c}from"node:fs/promises";import{resolve as l}from"node:path";import{getConfiguration as u}from"@intlayer/config/node";const d=async(e,r,i,a,o,s=u())=>{let c=n(await e,a,i,o,s),d=o===`cjs`?`cjs`:`mjs`,{mainDir:f}=s.system;await t(l(f,`${r}.${d}`),c)},f=async(t=u(),n={})=>{let{formats:l,excludeKeys:f=[]}=n,p=l??t.build.outputFormat,{mainDir:m}=t.system;await c(m,{recursive:!0}),await e([...p.map(e=>({paths:r(t,f),importType:`json`,functionName:`getDictionaries`,fileName:`dictionaries`,format:e})),...p.map(e=>({paths:s(t,f),importType:`json`,functionName:`getUnmergedDictionaries`,fileName:`unmerged_dictionaries`,format:e})),...p.map(e=>({paths:i(t,e,f),importType:`javascript`,functionName:`getDynamicDictionaries`,fileName:`dynamic_dictionaries`,format:e})),...p.map(e=>({paths:a(t,e,f),importType:`javascript`,functionName:`getFetchDictionaries`,fileName:`fetch_dictionaries`,format:e})),...p.map(e=>({paths:o(t,f),importType:`json`,functionName:`getRemoteDictionaries`,fileName:`remote_dictionaries`,format:e}))],async({paths:e,fileName:n,format:r,functionName:i,importType:a})=>d(e,n,a,i,r,t))};export{f as createDictionaryEntryPoint};
+import { parallelize } from "../utils/parallelize.mjs";
+import { writeFileIfChanged } from "../writeFileIfChanged.mjs";
+import { generateDictionaryListContent } from "./generateDictionaryListContent.mjs";
+import { getBuiltDictionariesPath } from "./getBuiltDictionariesPath.mjs";
+import { getBuiltDynamicDictionariesPath } from "./getBuiltDynamicDictionariesPath.mjs";
+import { getBuiltFetchDictionariesPath } from "./getBuiltFetchDictionariesPath.mjs";
+import { getBuiltRemoteDictionariesPath } from "./getBuiltRemoteDictionariesPath.mjs";
+import { getBuiltUnmergedDictionariesPath } from "./getBuiltUnmergedDictionariesPath.mjs";
+import { mkdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import { getConfiguration } from "@intlayer/config/node";
+
+//#region src/createDictionaryEntryPoint/createDictionaryEntryPoint.ts
+const writeDictionaryFiles = async (paths, fileName, importType, functionName, format, configuration = getConfiguration()) => {
+	const content = generateDictionaryListContent(await paths, functionName, importType, format, configuration);
+	const extension = format === "cjs" ? "cjs" : "mjs";
+	const { mainDir } = configuration.system;
+	await writeFileIfChanged(resolve(mainDir, `${fileName}.${extension}`), content);
+};
+/**
+* This function generates a list of dictionaries in the main directory
+*/
+const createDictionaryEntryPoint = async (configuration = getConfiguration(), options = {}) => {
+	const { formats, excludeKeys = [] } = options;
+	const outputFormats = formats ?? configuration.build.outputFormat;
+	const { mainDir } = configuration.system;
+	await mkdir(mainDir, { recursive: true });
+	await parallelize([
+		...outputFormats.map((format) => ({
+			paths: getBuiltDictionariesPath(configuration, excludeKeys),
+			importType: "json",
+			functionName: "getDictionaries",
+			fileName: "dictionaries",
+			format
+		})),
+		...outputFormats.map((format) => ({
+			paths: getBuiltUnmergedDictionariesPath(configuration, excludeKeys),
+			importType: "json",
+			functionName: "getUnmergedDictionaries",
+			fileName: "unmerged_dictionaries",
+			format
+		})),
+		...outputFormats.map((format) => ({
+			paths: getBuiltDynamicDictionariesPath(configuration, format, excludeKeys),
+			importType: "javascript",
+			functionName: "getDynamicDictionaries",
+			fileName: "dynamic_dictionaries",
+			format
+		})),
+		...outputFormats.map((format) => ({
+			paths: getBuiltFetchDictionariesPath(configuration, format, excludeKeys),
+			importType: "javascript",
+			functionName: "getFetchDictionaries",
+			fileName: "fetch_dictionaries",
+			format
+		})),
+		...outputFormats.map((format) => ({
+			paths: getBuiltRemoteDictionariesPath(configuration, excludeKeys),
+			importType: "json",
+			functionName: "getRemoteDictionaries",
+			fileName: "remote_dictionaries",
+			format
+		}))
+	], async ({ paths, fileName, format, functionName, importType }) => writeDictionaryFiles(paths, fileName, importType, functionName, format, configuration));
+};
+
+//#endregion
+export { createDictionaryEntryPoint };
 //# sourceMappingURL=createDictionaryEntryPoint.mjs.map