@intlayer/chokidar 5.8.1-canary.0 → 6.0.0-canary.0

package/dist/cjs/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeFetchDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeFetchDictionary.ts"],"sourcesContent":["import { getConfiguration, normalizePath } from '@intlayer/config';\nimport { mkdir, writeFile } from 'fs/promises';\nimport { relative, resolve } from 'path';\nimport { parallelize } from '../../../utils/parallelize';\nimport type {\n  LocalizedDictionaryOutput,\n  LocalizedDictionaryResult,\n} from './writeDynamicDictionary';\n\n/**\n * This function generates the content of the dictionary list file\n */\nexport const generateDictionaryEntryPoint = (\n  localedDictionariesPathsRecord: LocalizedDictionaryResult,\n  format: 'cjs' | 'esm' = 'esm',\n  configuration = getConfiguration()\n): string => {\n  const { fetchDictionariesDir } = configuration.content;\n  const { liveSyncURL } = configuration.editor;\n\n  let content = '';\n\n  const formattedDictionaryMap: string = Object.entries(\n    localedDictionariesPathsRecord\n  )\n    .map(([locale, dictionary]) => {\n      const relativePath = normalizePath(\n        relative(fetchDictionariesDir, dictionary.dictionaryPath)\n      );\n\n      if (format === 'esm') {\n        return `  '${locale}': () => (async () => { try {return await fetch('${liveSyncURL}/dictionaries/${dictionary.dictionary.key}/${locale}').then(res => res.json())} catch (_error) {return await import('./${relativePath}', { assert: { type: 'json' }}).then(mod => mod.default)}})()`;\n      }\n\n      return `  '${locale}': () => (async () => { try {return await fetch('${liveSyncURL}/dictionaries/${dictionary.dictionary.key}/${locale}').then(res => res.json())} catch (_error) {return Promise.resolve(require('./${relativePath}'))}})()`;\n    })\n    .join(',\\n');\n\n  content += `const content = {\\n${formattedDictionaryMap}\\n};\\n`;\n\n  if (format === 'esm') content += `export default content;\\n`;\n  if (format === 'cjs') content += `module.exports = content;\\n`;\n\n  return content;\n};\n\n/**\n * Write the localized dictionaries to the dictionariesDir\n * @param mergedDictionaries - The merged dictionaries\n * @param configuration - The configuration\n * @returns The final dictionaries\n *\n * @example\n * ```ts\n * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);\n * const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);\n * console.log(finalDictionaries);\n *\n * // .intlayer/fetch_dictionaries/home.json\n * // { key: 'home', content: { ... } },\n * ```\n */\nexport const writeFetchDictionary = async (\n  dynamicDictionaries: LocalizedDictionaryOutput,\n  configuration = getConfiguration(),\n  formats: ('cjs' | 'esm')[] = ['cjs', 'esm']\n): Promise<LocalizedDictionaryOutput> => {\n  const { fetchDictionariesDir } = configuration.content;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(fetchDictionariesDir), { recursive: true });\n\n  let resultDictionariesPaths: LocalizedDictionaryOutput = {};\n\n  // Write entry points for each dictionary in parallel\n  await parallelize(\n    Object.entries(dynamicDictionaries),\n    async ([key, localedDictionariesPathsRecord]) => {\n      if (key === 'undefined') return;\n\n      await parallelize(formats, async (format) => {\n        const extension = format === 'cjs' ? 'cjs' : 'mjs';\n        const content = generateDictionaryEntryPoint(\n          localedDictionariesPathsRecord,\n          format,\n          configuration\n        );\n\n        await writeFile(\n          resolve(fetchDictionariesDir, `${key}.${extension}`),\n          content\n        );\n      });\n    }\n  );\n\n  return resultDictionariesPaths;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAgD;AAChD,sBAAiC;AACjC,kBAAkC;AAClC,yBAA4B;AASrB,MAAM,+BAA+B,CAC1C,gCACA,SAAwB,OACxB,oBAAgB,gCAAiB,MACtB;AACX,QAAM,EAAE,qBAAqB,IAAI,cAAc;AAC/C,QAAM,EAAE,YAAY,IAAI,cAAc;AAEtC,MAAI,UAAU;AAEd,QAAM,yBAAiC,OAAO;AAAA,IAC5C;AAAA,EACF,EACG,IAAI,CAAC,CAAC,QAAQ,UAAU,MAAM;AAC7B,UAAM,mBAAe;AAAA,UACnB,sBAAS,sBAAsB,WAAW,cAAc;AAAA,IAC1D;AAEA,QAAI,WAAW,OAAO;AACpB,aAAO,MAAM,MAAM,oDAAoD,WAAW,iBAAiB,WAAW,WAAW,GAAG,IAAI,MAAM,sEAAsE,YAAY;AAAA,IAC1N;AAEA,WAAO,MAAM,MAAM,oDAAoD,WAAW,iBAAiB,WAAW,WAAW,GAAG,IAAI,MAAM,iFAAiF,YAAY;AAAA,EACrO,CAAC,EACA,KAAK,KAAK;AAEb,aAAW;AAAA,EAAsB,sBAAsB;AAAA;AAAA;AAEvD,MAAI,WAAW,MAAO,YAAW;AAAA;AACjC,MAAI,WAAW,MAAO,YAAW;AAAA;AAEjC,SAAO;AACT;AAkBO,MAAM,uBAAuB,OAClC,qBACA,oBAAgB,gCAAiB,GACjC,UAA6B,CAAC,OAAO,KAAK,MACH;AACvC,QAAM,EAAE,qBAAqB,IAAI,cAAc;AAG/C,YAAM,2BAAM,qBAAQ,oBAAoB,GAAG,EAAE,WAAW,KAAK,CAAC;AAE9D,MAAI,0BAAqD,CAAC;AAG1D,YAAM;AAAA,IACJ,OAAO,QAAQ,mBAAmB;AAAA,IAClC,OAAO,CAAC,KAAK,8BAA8B,MAAM;AAC/C,UAAI,QAAQ,YAAa;AAEzB,gBAAM,gCAAY,SAAS,OAAO,WAAW;AAC3C,cAAM,YAAY,WAAW,QAAQ,QAAQ;AAC7C,cAAM,UAAU;AAAA,UACd;AAAA,UACA;AAAA,UACA;AAAA,QACF;AAEA,kBAAM;AAAA,cACJ,qBAAQ,sBAAsB,GAAG,GAAG,IAAI,SAAS,EAAE;AAAA,UACnD;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/cjs/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeMergedDictionary.cjs

@@ -26,31 +26,39 @@ var import_promises = require("fs/promises");
 var import_path = require("path");
 var import_mergeDictionaries = require('../../../mergeDictionaries.cjs');
 var import_processPerLocaleDictionary = require('../../../processPerLocaleDictionary.cjs');
+var import_parallelize = require('../../../utils/parallelize.cjs');
 var import_formatDictionaryText = require('./formatDictionaryText.cjs');
 const writeMergedDictionaries = async (groupedDictionaries, configuration = (0, import_config.getConfiguration)()) => {
   const { dictionariesDir } = configuration.content;
   await (0, import_promises.mkdir)((0, import_path.resolve)(dictionariesDir), { recursive: true });
-  let resultDictionariesPaths = {};
-  for await (const [key, dictionariesEntry] of Object.entries(
-    groupedDictionaries
-  )) {
-    if (key === "undefined") continue;
-    const multiLocaleDictionaries = dictionariesEntry.dictionaries.map(
-      (dictionary) => (0, import_processPerLocaleDictionary.processPerLocaleDictionary)(dictionary)
-    );
-    const mergedDictionary = (0, import_mergeDictionaries.mergeDictionaries)(multiLocaleDictionaries);
-    const contentString = (0, import_formatDictionaryText.formatDictionaryText)(mergedDictionary);
-    const outputFileName = `${key}.json`;
-    const resultFilePath = (0, import_path.resolve)(dictionariesDir, outputFileName);
-    await (0, import_promises.writeFile)(resultFilePath, contentString, "utf8").catch((err) => {
-      console.error(`Error creating merged ${outputFileName}:`, err);
-    });
-    resultDictionariesPaths[key] = {
-      dictionaryPath: resultFilePath,
-      dictionary: mergedDictionary
-    };
-  }
-  return resultDictionariesPaths;
+  const results = await (0, import_parallelize.parallelize)(
+    Object.entries(groupedDictionaries),
+    async ([key, dictionariesEntry]) => {
+      if (key === "undefined") {
+        return void 0;
+      }
+      const multiLocaleDictionaries = dictionariesEntry.dictionaries.map(
+        (dictionary) => (0, import_processPerLocaleDictionary.processPerLocaleDictionary)(dictionary)
+      );
+      const mergedDictionary = (0, import_mergeDictionaries.mergeDictionaries)(multiLocaleDictionaries);
+      const contentString = (0, import_formatDictionaryText.formatDictionaryText)(mergedDictionary);
+      const outputFileName = `${key}.json`;
+      const resultFilePath = (0, import_path.resolve)(dictionariesDir, outputFileName);
+      await (0, import_promises.writeFile)(resultFilePath, contentString, "utf8").catch((err) => {
+        console.error(`Error creating merged ${outputFileName}:`, err);
+      });
+      return [
+        key,
+        {
+          dictionaryPath: resultFilePath,
+          dictionary: mergedDictionary
+        }
+      ];
+    }
+  );
+  return Object.fromEntries(
+    results.filter(Boolean)
+  );
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeMergedDictionary.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeMergedDictionary.ts"],"sourcesContent":["import { getConfiguration } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport { mkdir, writeFile } from 'fs/promises';\nimport { resolve } from 'path';\nimport { mergeDictionaries } from '../../../mergeDictionaries';\nimport { processPerLocaleDictionary } from '../../../processPerLocaleDictionary';\nimport { formatDictionaryText } from './formatDictionaryText';\nimport { 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/dictionaries/home.json\n * // { key: 'home', content: { ... } },\n * ```\n */\nexport const writeMergedDictionaries = async (\n  groupedDictionaries: UnmergedDictionaryOutput,\n  configuration = getConfiguration()\n): Promise<MergedDictionaryOutput> => {\n  const { dictionariesDir } = configuration.content;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(dictionariesDir), { recursive: true });\n\n  let resultDictionariesPaths: MergedDictionaryOutput = {};\n\n  // Merge dictionaries with the same key and write to dictionariesDir\n  for await (const [key, dictionariesEntry] of Object.entries(\n    groupedDictionaries\n  )) {\n    if (key === 'undefined') continue;\n\n    const multiLocaleDictionaries = dictionariesEntry.dictionaries.map(\n      (dictionary) => processPerLocaleDictionary(dictionary)\n    );\n\n    const mergedDictionary = mergeDictionaries(multiLocaleDictionaries);\n\n    const contentString = formatDictionaryText(mergedDictionary);\n\n    const outputFileName = `${key}.json`;\n    const resultFilePath = resolve(dictionariesDir, outputFileName);\n\n    // Write the merged dictionary\n    await writeFile(resultFilePath, contentString, 'utf8').catch((err) => {\n      console.error(`Error creating merged ${outputFileName}:`, err);\n    });\n\n    resultDictionariesPaths[key] = {\n      dictionaryPath: resultFilePath,\n      dictionary: mergedDictionary,\n    };\n  }\n\n  return resultDictionariesPaths;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAiC;AAEjC,sBAAiC;AACjC,kBAAwB;AACxB,+BAAkC;AAClC,wCAA2C;AAC3C,kCAAqC;AA0B9B,MAAM,0BAA0B,OACrC,qBACA,oBAAgB,gCAAiB,MACG;AACpC,QAAM,EAAE,gBAAgB,IAAI,cAAc;AAG1C,YAAM,2BAAM,qBAAQ,eAAe,GAAG,EAAE,WAAW,KAAK,CAAC;AAEzD,MAAI,0BAAkD,CAAC;AAGvD,mBAAiB,CAAC,KAAK,iBAAiB,KAAK,OAAO;AAAA,IAClD;AAAA,EACF,GAAG;AACD,QAAI,QAAQ,YAAa;AAEzB,UAAM,0BAA0B,kBAAkB,aAAa;AAAA,MAC7D,CAAC,mBAAe,8DAA2B,UAAU;AAAA,IACvD;AAEA,UAAM,uBAAmB,4CAAkB,uBAAuB;AAElE,UAAM,oBAAgB,kDAAqB,gBAAgB;AAE3D,UAAM,iBAAiB,GAAG,GAAG;AAC7B,UAAM,qBAAiB,qBAAQ,iBAAiB,cAAc;AAG9D,cAAM,2BAAU,gBAAgB,eAAe,MAAM,EAAE,MAAM,CAAC,QAAQ;AACpE,cAAQ,MAAM,yBAAyB,cAAc,KAAK,GAAG;AAAA,IAC/D,CAAC;AAED,4BAAwB,GAAG,IAAI;AAAA,MAC7B,gBAAgB;AAAA,MAChB,YAAY;AAAA,IACd;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../../../../src/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeMergedDictionary.ts"],"sourcesContent":["import { getConfiguration } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport { mkdir, writeFile } from 'fs/promises';\nimport { resolve } from 'path';\nimport { mergeDictionaries } from '../../../mergeDictionaries';\nimport { processPerLocaleDictionary } from '../../../processPerLocaleDictionary';\nimport { parallelize } from '../../../utils/parallelize';\nimport { formatDictionaryText } from './formatDictionaryText';\nimport { UnmergedDictionaryOutput } from './writeUnmergedDictionary';\n\nexport type MergedDictionaryResult = {\n  dictionaryPath: string;\n  dictionary: Dictionary;\n};\n\nexport type MergedDictionaryOutput = Record<string, MergedDictionaryResult>;\n\n/**\n * Write the merged dictionaries to the dictionariesDir\n * @param groupedDictionaries - The grouped dictionaries\n * @param configuration - The configuration\n * @returns The merged dictionaries\n *\n * @example\n * ```ts\n * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);\n * const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);\n * console.log(finalDictionaries);\n *\n * // .intlayer/dictionary/home.json\n * // { key: 'home', content: { ... } },\n * ```\n */\nexport const writeMergedDictionaries = async (\n  groupedDictionaries: UnmergedDictionaryOutput,\n  configuration = getConfiguration()\n): Promise<MergedDictionaryOutput> => {\n  const { dictionariesDir } = configuration.content;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(dictionariesDir), { recursive: true });\n\n  const results = await parallelize(\n    Object.entries(groupedDictionaries),\n    async ([key, dictionariesEntry]) => {\n      if (key === 'undefined') {\n        return undefined as unknown as readonly [\n          string,\n          MergedDictionaryResult,\n        ];\n      }\n\n      const multiLocaleDictionaries = dictionariesEntry.dictionaries.map(\n        (dictionary) => processPerLocaleDictionary(dictionary)\n      );\n\n      const mergedDictionary = mergeDictionaries(multiLocaleDictionaries);\n\n      const contentString = formatDictionaryText(mergedDictionary);\n\n      const outputFileName = `${key}.json`;\n      const resultFilePath = resolve(dictionariesDir, outputFileName);\n\n      // Write the merged dictionary\n      await writeFile(resultFilePath, contentString, 'utf8').catch((err) => {\n        console.error(`Error creating merged ${outputFileName}:`, err);\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":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAiC;AAEjC,sBAAiC;AACjC,kBAAwB;AACxB,+BAAkC;AAClC,wCAA2C;AAC3C,yBAA4B;AAC5B,kCAAqC;AA0B9B,MAAM,0BAA0B,OACrC,qBACA,oBAAgB,gCAAiB,MACG;AACpC,QAAM,EAAE,gBAAgB,IAAI,cAAc;AAG1C,YAAM,2BAAM,qBAAQ,eAAe,GAAG,EAAE,WAAW,KAAK,CAAC;AAEzD,QAAM,UAAU,UAAM;AAAA,IACpB,OAAO,QAAQ,mBAAmB;AAAA,IAClC,OAAO,CAAC,KAAK,iBAAiB,MAAM;AAClC,UAAI,QAAQ,aAAa;AACvB,eAAO;AAAA,MAIT;AAEA,YAAM,0BAA0B,kBAAkB,aAAa;AAAA,QAC7D,CAAC,mBAAe,8DAA2B,UAAU;AAAA,MACvD;AAEA,YAAM,uBAAmB,4CAAkB,uBAAuB;AAElE,YAAM,oBAAgB,kDAAqB,gBAAgB;AAE3D,YAAM,iBAAiB,GAAG,GAAG;AAC7B,YAAM,qBAAiB,qBAAQ,iBAAiB,cAAc;AAG9D,gBAAM,2BAAU,gBAAgB,eAAe,MAAM,EAAE,MAAM,CAAC,QAAQ;AACpE,gBAAQ,MAAM,yBAAyB,cAAc,KAAK,GAAG;AAAA,MAC/D,CAAC;AAED,aAAO;AAAA,QACL;AAAA,QACA;AAAA,UACE,gBAAgB;AAAA,UAChB,YAAY;AAAA,QACd;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO,OAAO;AAAA,IACZ,QAAQ,OAAO,OAAO;AAAA,EACxB;AACF;","names":[]}

package/dist/cjs/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeRemoteDictionary.cjs

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var writeRemoteDictionary_exports = {};
+__export(writeRemoteDictionary_exports, {
+  writeRemoteDictionary: () => writeRemoteDictionary
+});
+module.exports = __toCommonJS(writeRemoteDictionary_exports);
+var import_config = require("@intlayer/config");
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var import_filterInvalidDictionaries = require('../../../filterInvalidDictionaries.cjs');
+var import_loadDictionaries = require('../../../loadDictionaries/index.cjs');
+var import_parallelize = require('../../../utils/parallelize.cjs');
+var import_formatDictionaryText = require('./formatDictionaryText.cjs');
+const writeRemoteDictionary = async (remoteDictionaries, configuration = (0, import_config.getConfiguration)()) => {
+  const { remoteDictionariesDir } = configuration.content;
+  await (0, import_promises.mkdir)((0, import_path.resolve)(remoteDictionariesDir), { recursive: true });
+  const filteredDictionaries = (0, import_filterInvalidDictionaries.filterInvalidDictionaries)(remoteDictionaries);
+  await (0, import_parallelize.parallelize)(
+    filteredDictionaries.filter((dictionary) => dictionary.key !== "undefined"),
+    async (dictionary) => {
+      const outputFileName = `${dictionary.key}.json`;
+      const resultFilePath = (0, import_path.resolve)(remoteDictionariesDir, outputFileName);
+      const contentString = (0, import_formatDictionaryText.formatDictionaryText)(dictionary);
+      await (0, import_promises.writeFile)(resultFilePath, contentString, "utf8").catch((err) => {
+        console.error(`Error creating merged ${outputFileName}:`, err);
+      });
+    }
+  );
+  return (0, import_loadDictionaries.formatDistantDictionaries)(remoteDictionaries);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  writeRemoteDictionary
+});
+//# sourceMappingURL=writeRemoteDictionary.cjs.map

package/dist/cjs/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeRemoteDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeRemoteDictionary.ts"],"sourcesContent":["import { getConfiguration } from '@intlayer/config';\nimport { Dictionary } from '@intlayer/core';\nimport { mkdir, writeFile } from 'fs/promises';\nimport { resolve } from 'path';\nimport { filterInvalidDictionaries } from '../../../filterInvalidDictionaries';\nimport { formatDistantDictionaries } from '../../../loadDictionaries';\nimport { parallelize } from '../../../utils/parallelize';\nimport { formatDictionaryText } from './formatDictionaryText';\n\n/**\n * Write the localized dictionaries to the dictionariesDir\n * @param mergedDictionaries - The merged dictionaries\n * @param configuration - The configuration\n * @returns The final dictionaries\n *\n * @example\n * ```ts\n * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);\n * const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);\n * console.log(finalDictionaries);\n *\n * // .intlayer/fetch_dictionaries/home.json\n * // { key: 'home', content: { ... } },\n * ```\n */\nexport const writeRemoteDictionary = async (\n  remoteDictionaries: Dictionary[],\n  configuration = getConfiguration()\n): Promise<Dictionary[]> => {\n  const { remoteDictionariesDir } = configuration.content;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(remoteDictionariesDir), { recursive: true });\n\n  const filteredDictionaries = filterInvalidDictionaries(remoteDictionaries);\n\n  // Merge dictionaries with the same key and write to dictionariesDir\n  await parallelize(\n    filteredDictionaries.filter((dictionary) => dictionary.key !== 'undefined'),\n    async (dictionary) => {\n      const outputFileName = `${dictionary.key}.json`;\n      const resultFilePath = resolve(remoteDictionariesDir, outputFileName);\n\n      const contentString = formatDictionaryText(dictionary);\n\n      // Write the merged dictionary\n      await writeFile(resultFilePath, contentString, 'utf8').catch((err) => {\n        console.error(`Error creating merged ${outputFileName}:`, err);\n      });\n    }\n  );\n\n  return formatDistantDictionaries(remoteDictionaries);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAiC;AAEjC,sBAAiC;AACjC,kBAAwB;AACxB,uCAA0C;AAC1C,8BAA0C;AAC1C,yBAA4B;AAC5B,kCAAqC;AAkB9B,MAAM,wBAAwB,OACnC,oBACA,oBAAgB,gCAAiB,MACP;AAC1B,QAAM,EAAE,sBAAsB,IAAI,cAAc;AAGhD,YAAM,2BAAM,qBAAQ,qBAAqB,GAAG,EAAE,WAAW,KAAK,CAAC;AAE/D,QAAM,2BAAuB,4DAA0B,kBAAkB;AAGzE,YAAM;AAAA,IACJ,qBAAqB,OAAO,CAAC,eAAe,WAAW,QAAQ,WAAW;AAAA,IAC1E,OAAO,eAAe;AACpB,YAAM,iBAAiB,GAAG,WAAW,GAAG;AACxC,YAAM,qBAAiB,qBAAQ,uBAAuB,cAAc;AAEpE,YAAM,oBAAgB,kDAAqB,UAAU;AAGrD,gBAAM,2BAAU,gBAAgB,eAAe,MAAM,EAAE,MAAM,CAAC,QAAQ;AACpE,gBAAQ,MAAM,yBAAyB,cAAc,KAAK,GAAG;AAAA,MAC/D,CAAC;AAAA,IACH;AAAA,EACF;AAEA,aAAO,mDAA0B,kBAAkB;AACrD;","names":[]}

package/dist/cjs/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeUnmergedDictionary.cjs

@@ -24,39 +24,54 @@ module.exports = __toCommonJS(writeUnmergedDictionary_exports);
 var import_config = require("@intlayer/config");
 var import_promises = require("fs/promises");
 var import_path = require("path");
+var import_filterInvalidDictionaries = require('../../../filterInvalidDictionaries.cjs');
+var import_orderDictionaries = require('../../../orderDictionaries.cjs');
+var import_parallelize = require('../../../utils/parallelize.cjs');
 var import_formatDictionaryText = require('./formatDictionaryText.cjs');
-const groupDictionariesByKey = (dictionaries) => {
-  return dictionaries.reduce(
-    (acc, dictionary) => {
-      const key = dictionary.key;
-      if (!acc[key]) {
-        acc[key] = [];
-      }
-      acc[key].push(dictionary);
-      return acc;
-    },
-    {}
-  );
-};
+const groupDictionariesByKey = (dictionaries) => dictionaries.reduce(
+  (acc, dictionary) => {
+    const key = dictionary.key;
+    if (!acc[key]) {
+      acc[key] = [];
+    }
+    acc[key].push(dictionary);
+    return acc;
+  },
+  {}
+);
 const writeUnmergedDictionaries = async (dictionaries, configuration = (0, import_config.getConfiguration)()) => {
   const { unmergedDictionariesDir } = configuration.content;
   await (0, import_promises.mkdir)((0, import_path.resolve)(unmergedDictionariesDir), { recursive: true });
-  const groupedDictionaries = groupDictionariesByKey(dictionaries);
-  let resultDictionariesPaths = {};
-  for await (const [key, dictionaries2] of Object.entries(groupedDictionaries)) {
-    if (key === "undefined") continue;
-    const contentString = (0, import_formatDictionaryText.formatDictionaryText)(dictionaries2);
-    const outputFileName = `${key}.json`;
-    const unmergedFilePath = (0, import_path.resolve)(unmergedDictionariesDir, outputFileName);
-    await (0, import_promises.writeFile)(unmergedFilePath, contentString, "utf8").catch((err) => {
-      console.error(`Error creating unmerged ${outputFileName}:`, err);
-    });
-    resultDictionariesPaths[key] = {
-      dictionaryPath: unmergedFilePath,
-      dictionaries: dictionaries2
-    };
-  }
-  return resultDictionariesPaths;
+  const filteredDictionaries = (0, import_filterInvalidDictionaries.filterInvalidDictionaries)(dictionaries);
+  const groupedDictionaries = groupDictionariesByKey(filteredDictionaries);
+  const results = await (0, import_parallelize.parallelize)(
+    Object.entries(groupedDictionaries),
+    async ([key, dictionaries2]) => {
+      if (key === "undefined") {
+        return void 0;
+      }
+      const orderedDictionaries = (0, import_orderDictionaries.orderDictionaries)(
+        dictionaries2,
+        configuration
+      );
+      const contentString = (0, import_formatDictionaryText.formatDictionaryText)(orderedDictionaries);
+      const outputFileName = `${key}.json`;
+      const unmergedFilePath = (0, import_path.resolve)(unmergedDictionariesDir, outputFileName);
+      await (0, import_promises.writeFile)(unmergedFilePath, contentString, "utf8").catch((err) => {
+        console.error(`${import_config.x} Error creating unmerged ${outputFileName}:`, err);
+      });
+      return [
+        key,
+        {
+          dictionaryPath: unmergedFilePath,
+          dictionaries: dictionaries2
+        }
+      ];
+    }
+  );
+  return Object.fromEntries(
+    results.filter(Boolean)
+  );
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeUnmergedDictionary.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeUnmergedDictionary.ts"],"sourcesContent":["import { getConfiguration } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport { mkdir, writeFile } from 'fs/promises';\nimport { resolve } from 'path';\nimport { formatDictionaryText } from './formatDictionaryText';\n\nconst groupDictionariesByKey = (\n  dictionaries: Dictionary[]\n): Record<string, Dictionary[]> => {\n  return 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};\n\nexport type UnmergedDictionaryResult = {\n  dictionaryPath: string;\n  dictionaries: Dictionary[];\n};\n\nexport type UnmergedDictionaryOutput = Record<string, UnmergedDictionaryResult>;\n\n/**\n * Write the unmerged dictionaries to the unmergedDictionariesDir\n * @param dictionaries - The dictionaries to write\n * @param configuration - The configuration\n * @returns The grouped dictionaries\n *\n * @example\n * ```ts\n * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);\n * console.log(unmergedDictionaries);\n *\n * // .intlayer/unmerged_dictionaries/home.json\n * // {\n * //   [\n * //     { key: 'home', content: { ... } },\n * //     { key: 'home', content: { ... } },\n * //   ],\n * // }\n * ```\n */\nexport const writeUnmergedDictionaries = async (\n  dictionaries: Dictionary[],\n  configuration = getConfiguration()\n): Promise<UnmergedDictionaryOutput> => {\n  const { unmergedDictionariesDir } = configuration.content;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(unmergedDictionariesDir), { recursive: true });\n\n  //  Group dictionaries by key and write to unmergedDictionariesDir\n  const groupedDictionaries = groupDictionariesByKey(dictionaries);\n\n  let resultDictionariesPaths: UnmergedDictionaryOutput = {};\n\n  for await (const [key, dictionaries] of Object.entries(groupedDictionaries)) {\n    if (key === 'undefined') continue;\n\n    const contentString = formatDictionaryText(dictionaries);\n\n    const outputFileName = `${key}.json`;\n    const unmergedFilePath = resolve(unmergedDictionariesDir, outputFileName);\n\n    // Write the grouped dictionaries\n    await writeFile(unmergedFilePath, contentString, 'utf8').catch((err) => {\n      console.error(`Error creating unmerged ${outputFileName}:`, err);\n    });\n\n    resultDictionariesPaths[key] = {\n      dictionaryPath: unmergedFilePath,\n      dictionaries: dictionaries,\n    };\n  }\n\n  return resultDictionariesPaths;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAiC;AAEjC,sBAAiC;AACjC,kBAAwB;AACxB,kCAAqC;AAErC,MAAM,yBAAyB,CAC7B,iBACiC;AACjC,SAAO,aAAa;AAAA,IAClB,CAAC,KAAK,eAAe;AACnB,YAAM,MAAM,WAAW;AACvB,UAAI,CAAC,IAAI,GAAG,GAAG;AACb,YAAI,GAAG,IAAI,CAAC;AAAA,MACd;AACA,UAAI,GAAG,EAAE,KAAK,UAAU;AACxB,aAAO;AAAA,IACT;AAAA,IACA,CAAC;AAAA,EACH;AACF;AA6BO,MAAM,4BAA4B,OACvC,cACA,oBAAgB,gCAAiB,MACK;AACtC,QAAM,EAAE,wBAAwB,IAAI,cAAc;AAGlD,YAAM,2BAAM,qBAAQ,uBAAuB,GAAG,EAAE,WAAW,KAAK,CAAC;AAGjE,QAAM,sBAAsB,uBAAuB,YAAY;AAE/D,MAAI,0BAAoD,CAAC;AAEzD,mBAAiB,CAAC,KAAKA,aAAY,KAAK,OAAO,QAAQ,mBAAmB,GAAG;AAC3E,QAAI,QAAQ,YAAa;AAEzB,UAAM,oBAAgB,kDAAqBA,aAAY;AAEvD,UAAM,iBAAiB,GAAG,GAAG;AAC7B,UAAM,uBAAmB,qBAAQ,yBAAyB,cAAc;AAGxE,cAAM,2BAAU,kBAAkB,eAAe,MAAM,EAAE,MAAM,CAAC,QAAQ;AACtE,cAAQ,MAAM,2BAA2B,cAAc,KAAK,GAAG;AAAA,IACjE,CAAC;AAED,4BAAwB,GAAG,IAAI;AAAA,MAC7B,gBAAgB;AAAA,MAChB,cAAcA;AAAA,IAChB;AAAA,EACF;AAEA,SAAO;AACT;","names":["dictionaries"]}
+{"version":3,"sources":["../../../../../src/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeUnmergedDictionary.ts"],"sourcesContent":["import { getConfiguration, x } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport { mkdir, writeFile } from 'fs/promises';\nimport { resolve } from 'path';\nimport { filterInvalidDictionaries } from '../../../filterInvalidDictionaries';\nimport { orderDictionaries } from '../../../orderDictionaries';\nimport { parallelize } from '../../../utils/parallelize';\nimport { formatDictionaryText } from './formatDictionaryText';\n\nconst groupDictionariesByKey = (\n  dictionaries: Dictionary[]\n): Record<string, Dictionary[]> =>\n  dictionaries.reduce(\n    (acc, dictionary) => {\n      const key = dictionary.key;\n      if (!acc[key]) {\n        acc[key] = [];\n      }\n      acc[key].push(dictionary);\n      return acc;\n    },\n    {} as Record<string, Dictionary[]>\n  );\n\nexport type UnmergedDictionaryResult = {\n  dictionaryPath: string;\n  dictionaries: Dictionary[];\n};\n\nexport type UnmergedDictionaryOutput = Record<string, UnmergedDictionaryResult>;\n\n/**\n * Write the unmerged dictionaries to the unmergedDictionariesDir\n * @param dictionaries - The dictionaries to write\n * @param configuration - The configuration\n * @returns The grouped dictionaries\n *\n * @example\n * ```ts\n * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);\n * console.log(unmergedDictionaries);\n *\n * // .intlayer/unmerged_dictionaries/home.json\n * // {\n * //   [\n * //     { key: 'home', content: { ... } },\n * //     { key: 'home', content: { ... } },\n * //   ],\n * // }\n * ```\n */\nexport const writeUnmergedDictionaries = async (\n  dictionaries: Dictionary[],\n  configuration = getConfiguration()\n): Promise<UnmergedDictionaryOutput> => {\n  const { unmergedDictionariesDir } = configuration.content;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(unmergedDictionariesDir), { recursive: true });\n\n  const filteredDictionaries = filterInvalidDictionaries(dictionaries);\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      const contentString = formatDictionaryText(orderedDictionaries);\n\n      const outputFileName = `${key}.json`;\n      const unmergedFilePath = resolve(unmergedDictionariesDir, outputFileName);\n\n      // Write the grouped dictionaries\n      await writeFile(unmergedFilePath, contentString, 'utf8').catch((err) => {\n        console.error(`${x} Error creating unmerged ${outputFileName}:`, err);\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":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAoC;AAEpC,sBAAiC;AACjC,kBAAwB;AACxB,uCAA0C;AAC1C,+BAAkC;AAClC,yBAA4B;AAC5B,kCAAqC;AAErC,MAAM,yBAAyB,CAC7B,iBAEA,aAAa;AAAA,EACX,CAAC,KAAK,eAAe;AACnB,UAAM,MAAM,WAAW;AACvB,QAAI,CAAC,IAAI,GAAG,GAAG;AACb,UAAI,GAAG,IAAI,CAAC;AAAA,IACd;AACA,QAAI,GAAG,EAAE,KAAK,UAAU;AACxB,WAAO;AAAA,EACT;AAAA,EACA,CAAC;AACH;AA6BK,MAAM,4BAA4B,OACvC,cACA,oBAAgB,gCAAiB,MACK;AACtC,QAAM,EAAE,wBAAwB,IAAI,cAAc;AAGlD,YAAM,2BAAM,qBAAQ,uBAAuB,GAAG,EAAE,WAAW,KAAK,CAAC;AAEjE,QAAM,2BAAuB,4DAA0B,YAAY;AAGnE,QAAM,sBAAsB,uBAAuB,oBAAoB;AAEvE,QAAM,UAAU,UAAM;AAAA,IACpB,OAAO,QAAQ,mBAAmB;AAAA,IAClC,OAAO,CAAC,KAAKA,aAAY,MAAM;AAC7B,UAAI,QAAQ,aAAa;AACvB,eAAO;AAAA,MAIT;AAEA,YAAM,0BAAsB;AAAA,QAC1BA;AAAA,QACA;AAAA,MACF;AACA,YAAM,oBAAgB,kDAAqB,mBAAmB;AAE9D,YAAM,iBAAiB,GAAG,GAAG;AAC7B,YAAM,uBAAmB,qBAAQ,yBAAyB,cAAc;AAGxE,gBAAM,2BAAU,kBAAkB,eAAe,MAAM,EAAE,MAAM,CAAC,QAAQ;AACtE,gBAAQ,MAAM,GAAG,eAAC,4BAA4B,cAAc,KAAK,GAAG;AAAA,MACtE,CAAC;AAED,aAAO;AAAA,QACL;AAAA,QACA;AAAA,UACE,gBAAgB;AAAA,UAChB,cAAcA;AAAA,QAChB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO,OAAO;AAAA,IACZ,QAAQ,OAAO,OAAO;AAAA,EAGxB;AACF;","names":["dictionaries"]}

package/dist/cjs/transpiler/dictionary_to_main/createDictionaryEntryPoint.cjs

@@ -22,11 +22,14 @@ __export(createDictionaryEntryPoint_exports, {
 });
 module.exports = __toCommonJS(createDictionaryEntryPoint_exports);
 var import_config = require("@intlayer/config");
-var import_fs = require("fs");
+var import_promises = require("fs/promises");
 var import_path = require("path");
 var import_getBuiltDictionariesPath = require('../../getBuiltDictionariesPath.cjs');
 var import_getBuiltDynamicDictionariesPath = require('../../getBuiltDynamicDictionariesPath.cjs');
+var import_getBuiltFetchDictionariesPath = require('../../getBuiltFetchDictionariesPath.cjs');
+var import_getBuiltRemoteDictionariesPath = require('../../getBuiltRemoteDictionariesPath.cjs');
 var import_getBuiltUnmergedDictionariesPath = require('../../getBuiltUnmergedDictionariesPath.cjs');
+var import_parallelize = require('../../utils/parallelize.cjs');
 var import_generateDictionaryListContent = require('./generateDictionaryListContent.cjs');
 const filterDictionaries = (paths, keys) => {
   if (!keys) return paths;
@@ -34,50 +37,52 @@ const filterDictionaries = (paths, keys) => {
     (path) => keys.some((key) => path.endsWith(`${key}.json`))
   );
 };
-const writeDictionaryFiles = (paths, fileName, format, configuration = (0, import_config.getConfiguration)()) => {
+const writeDictionaryFiles = async (paths, fileName, format, configuration = (0, import_config.getConfiguration)()) => {
   const content = (0, import_generateDictionaryListContent.generateDictionaryListContent)(paths, format, configuration);
   const extension = format === "cjs" ? "cjs" : "mjs";
   const { mainDir } = configuration.content;
-  (0, import_fs.writeFileSync)((0, import_path.resolve)(mainDir, `${fileName}.${extension}`), content);
+  await (0, import_promises.writeFile)((0, import_path.resolve)(mainDir, `${fileName}.${extension}`), content);
 };
-const createDictionaryEntryPoint = (configuration = (0, import_config.getConfiguration)(), dictionariesKeys, formats = ["cjs", "esm"]) => {
+const createDictionaryEntryPoint = async (configuration = (0, import_config.getConfiguration)(), dictionariesKeys, formats = ["cjs", "esm"]) => {
   const { mainDir } = configuration.content;
-  if (!(0, import_fs.existsSync)(mainDir)) {
-    (0, import_fs.mkdirSync)(mainDir, { recursive: true });
-  }
+  await (0, import_promises.mkdir)(mainDir, { recursive: true });
+  const remoteDictionariesPath = (0, import_getBuiltRemoteDictionariesPath.getBuiltRemoteDictionariesPath)(configuration);
   const dictionariesPath = filterDictionaries(
     (0, import_getBuiltDictionariesPath.getBuiltDictionariesPath)(configuration),
     dictionariesKeys
   );
-  for (const format of formats) {
-    writeDictionaryFiles(
-      dictionariesPath,
-      "dictionaries",
-      format,
-      configuration
-    );
-  }
   const unmergedDictionariesPath = (0, import_getBuiltUnmergedDictionariesPath.getBuiltUnmergedDictionariesPath)(configuration);
-  for (const format of formats) {
-    writeDictionaryFiles(
-      unmergedDictionariesPath,
-      "unmerged_dictionaries",
-      format,
-      configuration
-    );
-  }
-  for (const format of formats) {
-    const dynamicDictionariesPathCJS = (0, import_getBuiltDynamicDictionariesPath.getBuiltDynamicDictionariesPath)(
-      configuration,
+  const writeOperations = [
+    ...formats.map((format) => ({
+      paths: remoteDictionariesPath,
+      fileName: "remote_dictionaries",
       format
-    );
-    writeDictionaryFiles(
-      dynamicDictionariesPathCJS,
-      "dynamic_dictionaries",
-      format,
-      configuration
-    );
-  }
+    })),
+    ...formats.map((format) => ({
+      paths: dictionariesPath,
+      fileName: "dictionaries",
+      format
+    })),
+    ...formats.map((format) => ({
+      paths: unmergedDictionariesPath,
+      fileName: "unmerged_dictionaries",
+      format
+    })),
+    ...formats.map((format) => ({
+      paths: (0, import_getBuiltDynamicDictionariesPath.getBuiltDynamicDictionariesPath)(configuration, format),
+      fileName: "dynamic_dictionaries",
+      format
+    })),
+    ...formats.map((format) => ({
+      paths: (0, import_getBuiltFetchDictionariesPath.getBuiltFetchDictionariesPath)(configuration, format),
+      fileName: "fetch_dictionaries",
+      format
+    }))
+  ];
+  await (0, import_parallelize.parallelize)(
+    writeOperations,
+    async ({ paths, fileName, format }) => writeDictionaryFiles(paths, fileName, format, configuration)
+  );
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/transpiler/dictionary_to_main/createDictionaryEntryPoint.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/transpiler/dictionary_to_main/createDictionaryEntryPoint.ts"],"sourcesContent":["import { getConfiguration } from '@intlayer/config';\nimport { existsSync, mkdirSync, writeFileSync } from 'fs';\nimport { resolve } from 'path';\nimport { getBuiltDictionariesPath } from '../../getBuiltDictionariesPath';\nimport { getBuiltDynamicDictionariesPath } from '../../getBuiltDynamicDictionariesPath';\nimport { getBuiltUnmergedDictionariesPath } from '../../getBuiltUnmergedDictionariesPath';\nimport { generateDictionaryListContent } from './generateDictionaryListContent';\n\nconst filterDictionaries = (paths: string[], keys?: string[]) => {\n  if (!keys) return paths;\n  return paths.filter((path) =>\n    keys.some((key) => path.endsWith(`${key}.json`))\n  );\n};\n\nconst writeDictionaryFiles = (\n  paths: string[],\n  fileName: string,\n  format: 'cjs' | 'esm',\n  configuration = getConfiguration()\n) => {\n  const content = generateDictionaryListContent(paths, format, configuration);\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n\n  const { mainDir } = configuration.content;\n\n  writeFileSync(resolve(mainDir, `${fileName}.${extension}`), content);\n};\n\n/**\n * This function generates a list of dictionaries in the main directory\n */\nexport const createDictionaryEntryPoint = (\n  configuration = getConfiguration(),\n  dictionariesKeys?: string[],\n  formats: ('cjs' | 'esm')[] = ['cjs', 'esm']\n) => {\n  const { mainDir } = configuration.content;\n\n  // Create main directory if it doesn't exist\n  if (!existsSync(mainDir)) {\n    mkdirSync(mainDir, { recursive: true });\n  }\n\n  const dictionariesPath = filterDictionaries(\n    getBuiltDictionariesPath(configuration),\n    dictionariesKeys\n  );\n\n  for (const format of formats) {\n    writeDictionaryFiles(\n      dictionariesPath,\n      'dictionaries',\n      format,\n      configuration\n    );\n  }\n\n  const unmergedDictionariesPath =\n    getBuiltUnmergedDictionariesPath(configuration);\n\n  for (const format of formats) {\n    writeDictionaryFiles(\n      unmergedDictionariesPath,\n      'unmerged_dictionaries',\n      format,\n      configuration\n    );\n  }\n\n  for (const format of formats) {\n    const dynamicDictionariesPathCJS = getBuiltDynamicDictionariesPath(\n      configuration,\n      format\n    );\n\n    writeDictionaryFiles(\n      dynamicDictionariesPathCJS,\n      'dynamic_dictionaries',\n      format,\n      configuration\n    );\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAiC;AACjC,gBAAqD;AACrD,kBAAwB;AACxB,sCAAyC;AACzC,6CAAgD;AAChD,8CAAiD;AACjD,2CAA8C;AAE9C,MAAM,qBAAqB,CAAC,OAAiB,SAAoB;AAC/D,MAAI,CAAC,KAAM,QAAO;AAClB,SAAO,MAAM;AAAA,IAAO,CAAC,SACnB,KAAK,KAAK,CAAC,QAAQ,KAAK,SAAS,GAAG,GAAG,OAAO,CAAC;AAAA,EACjD;AACF;AAEA,MAAM,uBAAuB,CAC3B,OACA,UACA,QACA,oBAAgB,gCAAiB,MAC9B;AACH,QAAM,cAAU,oEAA8B,OAAO,QAAQ,aAAa;AAC1E,QAAM,YAAY,WAAW,QAAQ,QAAQ;AAE7C,QAAM,EAAE,QAAQ,IAAI,cAAc;AAElC,mCAAc,qBAAQ,SAAS,GAAG,QAAQ,IAAI,SAAS,EAAE,GAAG,OAAO;AACrE;AAKO,MAAM,6BAA6B,CACxC,oBAAgB,gCAAiB,GACjC,kBACA,UAA6B,CAAC,OAAO,KAAK,MACvC;AACH,QAAM,EAAE,QAAQ,IAAI,cAAc;AAGlC,MAAI,KAAC,sBAAW,OAAO,GAAG;AACxB,6BAAU,SAAS,EAAE,WAAW,KAAK,CAAC;AAAA,EACxC;AAEA,QAAM,mBAAmB;AAAA,QACvB,0DAAyB,aAAa;AAAA,IACtC;AAAA,EACF;AAEA,aAAW,UAAU,SAAS;AAC5B;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,QAAM,+BACJ,0EAAiC,aAAa;AAEhD,aAAW,UAAU,SAAS;AAC5B;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,aAAW,UAAU,SAAS;AAC5B,UAAM,iCAA6B;AAAA,MACjC;AAAA,MACA;AAAA,IACF;AAEA;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../../../src/transpiler/dictionary_to_main/createDictionaryEntryPoint.ts"],"sourcesContent":["import { getConfiguration } from '@intlayer/config';\nimport { mkdir, writeFile } from 'fs/promises';\nimport { resolve } from 'path';\nimport { getBuiltDictionariesPath } from '../../getBuiltDictionariesPath';\nimport { getBuiltDynamicDictionariesPath } from '../../getBuiltDynamicDictionariesPath';\nimport { getBuiltFetchDictionariesPath } from '../../getBuiltFetchDictionariesPath';\nimport { getBuiltRemoteDictionariesPath } from '../../getBuiltRemoteDictionariesPath';\nimport { getBuiltUnmergedDictionariesPath } from '../../getBuiltUnmergedDictionariesPath';\nimport { parallelize } from '../../utils/parallelize';\nimport { generateDictionaryListContent } from './generateDictionaryListContent';\n\nconst filterDictionaries = (paths: string[], keys?: string[]) => {\n  if (!keys) return paths;\n  return paths.filter((path) =>\n    keys.some((key) => path.endsWith(`${key}.json`))\n  );\n};\n\nconst writeDictionaryFiles = async (\n  paths: string[],\n  fileName: string,\n  format: 'cjs' | 'esm',\n  configuration = getConfiguration()\n) => {\n  const content = generateDictionaryListContent(paths, format, configuration);\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n\n  const { mainDir } = configuration.content;\n\n  await writeFile(resolve(mainDir, `${fileName}.${extension}`), content);\n};\n\n/**\n * This function generates a list of dictionaries in the main directory\n */\nexport const createDictionaryEntryPoint = async (\n  configuration = getConfiguration(),\n  dictionariesKeys?: string[],\n  formats: ('cjs' | 'esm')[] = ['cjs', 'esm']\n) => {\n  const { mainDir } = configuration.content;\n\n  await mkdir(mainDir, { recursive: true });\n\n  const remoteDictionariesPath = getBuiltRemoteDictionariesPath(configuration);\n  const dictionariesPath = filterDictionaries(\n    getBuiltDictionariesPath(configuration),\n    dictionariesKeys\n  );\n  const unmergedDictionariesPath =\n    getBuiltUnmergedDictionariesPath(configuration);\n\n  const writeOperations = [\n    ...formats.map((format) => ({\n      paths: remoteDictionariesPath,\n      fileName: 'remote_dictionaries' as const,\n      format,\n    })),\n    ...formats.map((format) => ({\n      paths: dictionariesPath,\n      fileName: 'dictionaries' as const,\n      format,\n    })),\n    ...formats.map((format) => ({\n      paths: unmergedDictionariesPath,\n      fileName: 'unmerged_dictionaries' as const,\n      format,\n    })),\n    ...formats.map((format) => ({\n      paths: getBuiltDynamicDictionariesPath(configuration, format),\n      fileName: 'dynamic_dictionaries' as const,\n      format,\n    })),\n    ...formats.map((format) => ({\n      paths: getBuiltFetchDictionariesPath(configuration, format),\n      fileName: 'fetch_dictionaries' as const,\n      format,\n    })),\n  ];\n\n  await parallelize(writeOperations, async ({ paths, fileName, format }) =>\n    writeDictionaryFiles(paths, fileName, format, configuration)\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAiC;AACjC,sBAAiC;AACjC,kBAAwB;AACxB,sCAAyC;AACzC,6CAAgD;AAChD,2CAA8C;AAC9C,4CAA+C;AAC/C,8CAAiD;AACjD,yBAA4B;AAC5B,2CAA8C;AAE9C,MAAM,qBAAqB,CAAC,OAAiB,SAAoB;AAC/D,MAAI,CAAC,KAAM,QAAO;AAClB,SAAO,MAAM;AAAA,IAAO,CAAC,SACnB,KAAK,KAAK,CAAC,QAAQ,KAAK,SAAS,GAAG,GAAG,OAAO,CAAC;AAAA,EACjD;AACF;AAEA,MAAM,uBAAuB,OAC3B,OACA,UACA,QACA,oBAAgB,gCAAiB,MAC9B;AACH,QAAM,cAAU,oEAA8B,OAAO,QAAQ,aAAa;AAC1E,QAAM,YAAY,WAAW,QAAQ,QAAQ;AAE7C,QAAM,EAAE,QAAQ,IAAI,cAAc;AAElC,YAAM,+BAAU,qBAAQ,SAAS,GAAG,QAAQ,IAAI,SAAS,EAAE,GAAG,OAAO;AACvE;AAKO,MAAM,6BAA6B,OACxC,oBAAgB,gCAAiB,GACjC,kBACA,UAA6B,CAAC,OAAO,KAAK,MACvC;AACH,QAAM,EAAE,QAAQ,IAAI,cAAc;AAElC,YAAM,uBAAM,SAAS,EAAE,WAAW,KAAK,CAAC;AAExC,QAAM,6BAAyB,sEAA+B,aAAa;AAC3E,QAAM,mBAAmB;AAAA,QACvB,0DAAyB,aAAa;AAAA,IACtC;AAAA,EACF;AACA,QAAM,+BACJ,0EAAiC,aAAa;AAEhD,QAAM,kBAAkB;AAAA,IACtB,GAAG,QAAQ,IAAI,CAAC,YAAY;AAAA,MAC1B,OAAO;AAAA,MACP,UAAU;AAAA,MACV;AAAA,IACF,EAAE;AAAA,IACF,GAAG,QAAQ,IAAI,CAAC,YAAY;AAAA,MAC1B,OAAO;AAAA,MACP,UAAU;AAAA,MACV;AAAA,IACF,EAAE;AAAA,IACF,GAAG,QAAQ,IAAI,CAAC,YAAY;AAAA,MAC1B,OAAO;AAAA,MACP,UAAU;AAAA,MACV;AAAA,IACF,EAAE;AAAA,IACF,GAAG,QAAQ,IAAI,CAAC,YAAY;AAAA,MAC1B,WAAO,wEAAgC,eAAe,MAAM;AAAA,MAC5D,UAAU;AAAA,MACV;AAAA,IACF,EAAE;AAAA,IACF,GAAG,QAAQ,IAAI,CAAC,YAAY;AAAA,MAC1B,WAAO,oEAA8B,eAAe,MAAM;AAAA,MAC1D,UAAU;AAAA,MACV;AAAA,IACF,EAAE;AAAA,EACJ;AAEA,YAAM;AAAA,IAAY;AAAA,IAAiB,OAAO,EAAE,OAAO,UAAU,OAAO,MAClE,qBAAqB,OAAO,UAAU,QAAQ,aAAa;AAAA,EAC7D;AACF;","names":[]}

package/dist/cjs/transpiler/dictionary_to_type/createModuleAugmentation.cjs

@@ -34,7 +34,7 @@ __export(createModuleAugmentation_exports, {
 module.exports = __toCommonJS(createModuleAugmentation_exports);
 var import_config = require("@intlayer/config");
 var import_fast_glob = __toESM(require("fast-glob"));
-var import_fs = require("fs");
+var import_promises = require("fs/promises");
 var import_path = require("path");
 var import_getFileHash = require('../../utils/getFileHash.cjs');
 var import_kebabCaseToCamelCase = require('../../utils/kebabCaseToCamelCase.cjs');
@@ -90,11 +90,9 @@ ${formattedDictionaryMap}
   fileContent += `}`;
   return fileContent;
 };
-const createModuleAugmentation = (configuration = (0, import_config.getConfiguration)()) => {
+const createModuleAugmentation = async (configuration = (0, import_config.getConfiguration)()) => {
   const { moduleAugmentationDir, typesDir } = configuration.content;
-  if (!(0, import_fs.existsSync)(moduleAugmentationDir)) {
-    (0, import_fs.mkdirSync)(moduleAugmentationDir, { recursive: true });
-  }
+  await (0, import_promises.mkdir)(moduleAugmentationDir, { recursive: true });
   const dictionariesTypesDefinitions = import_fast_glob.default.sync(
     (0, import_config.normalizePath)(`${typesDir}/*.ts`),
     {
@@ -102,7 +100,7 @@ const createModuleAugmentation = (configuration = (0, import_config.getConfigura
     }
   );
   const tsContent = generateTypeIndexContent(dictionariesTypesDefinitions);
-  (0, import_fs.writeFileSync)((0, import_path.join)(moduleAugmentationDir, "intlayer.d.ts"), tsContent);
+  await (0, import_promises.writeFile)((0, import_path.join)(moduleAugmentationDir, "intlayer.d.ts"), tsContent);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/transpiler/dictionary_to_type/createModuleAugmentation.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/transpiler/dictionary_to_type/createModuleAugmentation.ts"],"sourcesContent":["import { Locales, getConfiguration, normalizePath } from '@intlayer/config';\nimport fg from 'fast-glob';\nimport { existsSync, mkdirSync, writeFileSync } from 'fs';\nimport { basename, extname, join, relative } from 'path';\nimport { getFileHash } from '../../utils/getFileHash';\nimport { kebabCaseToCamelCase } from '../../utils/kebabCaseToCamelCase';\n\nexport const getTypeName = (key: string): string =>\n  `${kebabCaseToCamelCase(key)}Content`;\n\nconst formatLocales = (locales: Locales[]): string =>\n  locales\n    .map((locale) => {\n      for (const key in Locales) {\n        if (Locales[key as keyof typeof Locales] === locale) {\n          return `Locales.${key}`;\n        }\n      }\n    })\n    .join(' | ');\n\n/**\n * This function generates the content of the module augmentation file\n */\nconst generateTypeIndexContent = (\n  typeFiles: string[],\n  configuration = getConfiguration()\n): string => {\n  const { content, internationalization } = configuration;\n  const { moduleAugmentationDir } = content;\n  const { locales, requiredLocales, strictMode } = internationalization;\n\n  let fileContent =\n    \"/* eslint-disable */\\nimport { Locales } from 'intlayer';\\n\";\n\n  const dictionariesRef = typeFiles.map((dictionaryPath) => ({\n    relativePath: `./${relative(moduleAugmentationDir, dictionaryPath)}`,\n    id: basename(dictionaryPath, extname(dictionaryPath)), // Get the base name as the dictionary id (without the extension)\n    hash: `_${getFileHash(dictionaryPath)}`, // Get the hash of the dictionary to avoid conflicts\n  }));\n\n  // Import all dictionaries\n  dictionariesRef.forEach((dictionary) => {\n    fileContent += `import ${dictionary.hash} from '${dictionary.relativePath}';\\n`;\n  });\n\n  fileContent += '\\n';\n\n  // Format Dictionary Map\n  const formattedDictionaryMap: string = dictionariesRef\n    .map((dictionary) => `    \"${dictionary.id}\": typeof ${dictionary.hash};`)\n    .join('\\n');\n\n  const requiredLocalesValues =\n    requiredLocales.length > 0\n      ? requiredLocales.filter((locale) =>\n          locales.map((locale) => String(locale)).includes(String(locale))\n        )\n      : locales;\n\n  const formattedLocales = formatLocales(locales);\n  const formattedRequiredLocales = formatLocales(requiredLocalesValues);\n\n  const strictModeRecord =\n    strictMode === 'strict'\n      ? `interface IConfigLocales<Content> extends Record<DeclaredLocales, Content> {}`\n      : strictMode === 'inclusive'\n        ? `interface IConfigLocales<Content> extends Record<ExtractedLocales, Content>, Partial<Record<ExcludedLocales, Content>> {}`\n        : `interface IConfigLocales<Content> extends Partial<Record<Locales, Content>> {}`;\n\n  /**\n   * Write the module augmentation to extend the intlayer module with the dictionaries types\n   * Will suggest the type resulting of the dictionaries\n   *\n   * declare module 'intlayer' {\n   *   interface IntlayerDictionaryTypesConnector = {\n   *     dictionaries: {\n   *       id: DictionaryType;\n   *     }\n   *   }\n   *\n   *   type ConfigLocales = Locales.ENGLISH | Locales.FRENCH | Locales.SPANISH;\n   *   type ExtractedLocales = Extract<Locales, ConfigLocales>;\n   *\n   *   interface IConfigLocales<Content> extends Record<ExtractedLocales, Content>, Partial<Record<ExcludedLocales, Content>> {}\n   *\n   *\n   * }\n   * See https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation\n   */\n  fileContent += `declare module 'intlayer' {\\n`;\n  fileContent += `  interface IntlayerDictionaryTypesConnector {\\n${formattedDictionaryMap}\\n  }\\n\\n`;\n  fileContent += `  type DeclaredLocales = ${formattedLocales};\\n`;\n  fileContent += `  type RequiredLocales = ${formattedRequiredLocales};\\n`;\n  fileContent += `  type ExtractedLocales = Extract<Locales, RequiredLocales>;\\n`;\n  fileContent += `  type ExcludedLocales = Exclude<Locales, RequiredLocales>;\\n`;\n  fileContent += `  ${strictModeRecord}\\n`;\n  fileContent += `}`;\n\n  return fileContent;\n};\n\n/**\n * This function generates a index file merging all the types\n */\nexport const createModuleAugmentation = (\n  configuration = getConfiguration()\n) => {\n  const { moduleAugmentationDir, typesDir } = configuration.content;\n\n  // Create main directory if it doesn't exist\n  if (!existsSync(moduleAugmentationDir)) {\n    mkdirSync(moduleAugmentationDir, { recursive: true });\n  }\n\n  const dictionariesTypesDefinitions: string[] = fg.sync(\n    normalizePath(`${typesDir}/*.ts`),\n    {\n      ignore: ['**/*.d.ts'],\n    }\n  );\n  // Create the dictionary list file\n\n  const tsContent = generateTypeIndexContent(dictionariesTypesDefinitions);\n  writeFileSync(join(moduleAugmentationDir, 'intlayer.d.ts'), tsContent);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAyD;AACzD,uBAAe;AACf,gBAAqD;AACrD,kBAAkD;AAClD,yBAA4B;AAC5B,kCAAqC;AAE9B,MAAM,cAAc,CAAC,QAC1B,OAAG,kDAAqB,GAAG,CAAC;AAE9B,MAAM,gBAAgB,CAAC,YACrB,QACG,IAAI,CAAC,WAAW;AACf,aAAW,OAAO,uBAAS;AACzB,QAAI,sBAAQ,GAA2B,MAAM,QAAQ;AACnD,aAAO,WAAW,GAAG;AAAA,IACvB;AAAA,EACF;AACF,CAAC,EACA,KAAK,KAAK;AAKf,MAAM,2BAA2B,CAC/B,WACA,oBAAgB,gCAAiB,MACtB;AACX,QAAM,EAAE,SAAS,qBAAqB,IAAI;AAC1C,QAAM,EAAE,sBAAsB,IAAI;AAClC,QAAM,EAAE,SAAS,iBAAiB,WAAW,IAAI;AAEjD,MAAI,cACF;AAEF,QAAM,kBAAkB,UAAU,IAAI,CAAC,oBAAoB;AAAA,IACzD,cAAc,SAAK,sBAAS,uBAAuB,cAAc,CAAC;AAAA,IAClE,QAAI,sBAAS,oBAAgB,qBAAQ,cAAc,CAAC;AAAA;AAAA,IACpD,MAAM,QAAI,gCAAY,cAAc,CAAC;AAAA;AAAA,EACvC,EAAE;AAGF,kBAAgB,QAAQ,CAAC,eAAe;AACtC,mBAAe,UAAU,WAAW,IAAI,UAAU,WAAW,YAAY;AAAA;AAAA,EAC3E,CAAC;AAED,iBAAe;AAGf,QAAM,yBAAiC,gBACpC,IAAI,CAAC,eAAe,QAAQ,WAAW,EAAE,aAAa,WAAW,IAAI,GAAG,EACxE,KAAK,IAAI;AAEZ,QAAM,wBACJ,gBAAgB,SAAS,IACrB,gBAAgB;AAAA,IAAO,CAAC,WACtB,QAAQ,IAAI,CAACA,YAAW,OAAOA,OAAM,CAAC,EAAE,SAAS,OAAO,MAAM,CAAC;AAAA,EACjE,IACA;AAEN,QAAM,mBAAmB,cAAc,OAAO;AAC9C,QAAM,2BAA2B,cAAc,qBAAqB;AAEpE,QAAM,mBACJ,eAAe,WACX,kFACA,eAAe,cACb,8HACA;AAsBR,iBAAe;AAAA;AACf,iBAAe;AAAA,EAAmD,sBAAsB;AAAA;AAAA;AAAA;AACxF,iBAAe,4BAA4B,gBAAgB;AAAA;AAC3D,iBAAe,4BAA4B,wBAAwB;AAAA;AACnE,iBAAe;AAAA;AACf,iBAAe;AAAA;AACf,iBAAe,KAAK,gBAAgB;AAAA;AACpC,iBAAe;AAEf,SAAO;AACT;AAKO,MAAM,2BAA2B,CACtC,oBAAgB,gCAAiB,MAC9B;AACH,QAAM,EAAE,uBAAuB,SAAS,IAAI,cAAc;AAG1D,MAAI,KAAC,sBAAW,qBAAqB,GAAG;AACtC,6BAAU,uBAAuB,EAAE,WAAW,KAAK,CAAC;AAAA,EACtD;AAEA,QAAM,+BAAyC,iBAAAC,QAAG;AAAA,QAChD,6BAAc,GAAG,QAAQ,OAAO;AAAA,IAChC;AAAA,MACE,QAAQ,CAAC,WAAW;AAAA,IACtB;AAAA,EACF;AAGA,QAAM,YAAY,yBAAyB,4BAA4B;AACvE,mCAAc,kBAAK,uBAAuB,eAAe,GAAG,SAAS;AACvE;","names":["locale","fg"]}
+{"version":3,"sources":["../../../../src/transpiler/dictionary_to_type/createModuleAugmentation.ts"],"sourcesContent":["import { Locales, getConfiguration, normalizePath } from '@intlayer/config';\nimport fg from 'fast-glob';\nimport { mkdir, writeFile } from 'fs/promises';\nimport { basename, extname, join, relative } from 'path';\nimport { getFileHash } from '../../utils/getFileHash';\nimport { kebabCaseToCamelCase } from '../../utils/kebabCaseToCamelCase';\n\nexport const getTypeName = (key: string): string =>\n  `${kebabCaseToCamelCase(key)}Content`;\n\nconst formatLocales = (locales: Locales[]): string =>\n  locales\n    .map((locale) => {\n      for (const key in Locales) {\n        if (Locales[key as keyof typeof Locales] === locale) {\n          return `Locales.${key}`;\n        }\n      }\n    })\n    .join(' | ');\n\n/**\n * This function generates the content of the module augmentation file\n */\nconst generateTypeIndexContent = (\n  typeFiles: string[],\n  configuration = getConfiguration()\n): string => {\n  const { content, internationalization } = configuration;\n  const { moduleAugmentationDir } = content;\n  const { locales, requiredLocales, strictMode } = internationalization;\n\n  let fileContent =\n    \"/* eslint-disable */\\nimport { Locales } from 'intlayer';\\n\";\n\n  const dictionariesRef = typeFiles.map((dictionaryPath) => ({\n    relativePath: `./${relative(moduleAugmentationDir, dictionaryPath)}`,\n    id: basename(dictionaryPath, extname(dictionaryPath)), // Get the base name as the dictionary id (without the extension)\n    hash: `_${getFileHash(dictionaryPath)}`, // Get the hash of the dictionary to avoid conflicts\n  }));\n\n  // Import all dictionaries\n  dictionariesRef.forEach((dictionary) => {\n    fileContent += `import ${dictionary.hash} from '${dictionary.relativePath}';\\n`;\n  });\n\n  fileContent += '\\n';\n\n  // Format Dictionary Map\n  const formattedDictionaryMap: string = dictionariesRef\n    .map((dictionary) => `    \"${dictionary.id}\": typeof ${dictionary.hash};`)\n    .join('\\n');\n\n  const requiredLocalesValues =\n    requiredLocales.length > 0\n      ? requiredLocales.filter((locale) =>\n          locales.map((locale) => String(locale)).includes(String(locale))\n        )\n      : locales;\n\n  const formattedLocales = formatLocales(locales);\n  const formattedRequiredLocales = formatLocales(requiredLocalesValues);\n\n  const strictModeRecord =\n    strictMode === 'strict'\n      ? `interface IConfigLocales<Content> extends Record<DeclaredLocales, Content> {}`\n      : strictMode === 'inclusive'\n        ? `interface IConfigLocales<Content> extends Record<ExtractedLocales, Content>, Partial<Record<ExcludedLocales, Content>> {}`\n        : `interface IConfigLocales<Content> extends Partial<Record<Locales, Content>> {}`;\n\n  /**\n   * Write the module augmentation to extend the intlayer module with the dictionaries types\n   * Will suggest the type resulting of the dictionaries\n   *\n   * declare module 'intlayer' {\n   *   interface IntlayerDictionaryTypesConnector = {\n   *     dictionaries: {\n   *       id: DictionaryType;\n   *     }\n   *   }\n   *\n   *   type ConfigLocales = Locales.ENGLISH | Locales.FRENCH | Locales.SPANISH;\n   *   type ExtractedLocales = Extract<Locales, ConfigLocales>;\n   *\n   *   interface IConfigLocales<Content> extends Record<ExtractedLocales, Content>, Partial<Record<ExcludedLocales, Content>> {}\n   *\n   *\n   * }\n   * See https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation\n   */\n  fileContent += `declare module 'intlayer' {\\n`;\n  fileContent += `  interface IntlayerDictionaryTypesConnector {\\n${formattedDictionaryMap}\\n  }\\n\\n`;\n  fileContent += `  type DeclaredLocales = ${formattedLocales};\\n`;\n  fileContent += `  type RequiredLocales = ${formattedRequiredLocales};\\n`;\n  fileContent += `  type ExtractedLocales = Extract<Locales, RequiredLocales>;\\n`;\n  fileContent += `  type ExcludedLocales = Exclude<Locales, RequiredLocales>;\\n`;\n  fileContent += `  ${strictModeRecord}\\n`;\n  fileContent += `}`;\n\n  return fileContent;\n};\n\n/**\n * This function generates a index file merging all the types\n */\nexport const createModuleAugmentation = async (\n  configuration = getConfiguration()\n) => {\n  const { moduleAugmentationDir, typesDir } = configuration.content;\n\n  // Create main directory if it doesn't exist\n  await mkdir(moduleAugmentationDir, { recursive: true });\n\n  const dictionariesTypesDefinitions: string[] = fg.sync(\n    normalizePath(`${typesDir}/*.ts`),\n    {\n      ignore: ['**/*.d.ts'],\n    }\n  );\n  // Create the dictionary list file\n\n  const tsContent = generateTypeIndexContent(dictionariesTypesDefinitions);\n  await writeFile(join(moduleAugmentationDir, 'intlayer.d.ts'), tsContent);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAyD;AACzD,uBAAe;AACf,sBAAiC;AACjC,kBAAkD;AAClD,yBAA4B;AAC5B,kCAAqC;AAE9B,MAAM,cAAc,CAAC,QAC1B,OAAG,kDAAqB,GAAG,CAAC;AAE9B,MAAM,gBAAgB,CAAC,YACrB,QACG,IAAI,CAAC,WAAW;AACf,aAAW,OAAO,uBAAS;AACzB,QAAI,sBAAQ,GAA2B,MAAM,QAAQ;AACnD,aAAO,WAAW,GAAG;AAAA,IACvB;AAAA,EACF;AACF,CAAC,EACA,KAAK,KAAK;AAKf,MAAM,2BAA2B,CAC/B,WACA,oBAAgB,gCAAiB,MACtB;AACX,QAAM,EAAE,SAAS,qBAAqB,IAAI;AAC1C,QAAM,EAAE,sBAAsB,IAAI;AAClC,QAAM,EAAE,SAAS,iBAAiB,WAAW,IAAI;AAEjD,MAAI,cACF;AAEF,QAAM,kBAAkB,UAAU,IAAI,CAAC,oBAAoB;AAAA,IACzD,cAAc,SAAK,sBAAS,uBAAuB,cAAc,CAAC;AAAA,IAClE,QAAI,sBAAS,oBAAgB,qBAAQ,cAAc,CAAC;AAAA;AAAA,IACpD,MAAM,QAAI,gCAAY,cAAc,CAAC;AAAA;AAAA,EACvC,EAAE;AAGF,kBAAgB,QAAQ,CAAC,eAAe;AACtC,mBAAe,UAAU,WAAW,IAAI,UAAU,WAAW,YAAY;AAAA;AAAA,EAC3E,CAAC;AAED,iBAAe;AAGf,QAAM,yBAAiC,gBACpC,IAAI,CAAC,eAAe,QAAQ,WAAW,EAAE,aAAa,WAAW,IAAI,GAAG,EACxE,KAAK,IAAI;AAEZ,QAAM,wBACJ,gBAAgB,SAAS,IACrB,gBAAgB;AAAA,IAAO,CAAC,WACtB,QAAQ,IAAI,CAACA,YAAW,OAAOA,OAAM,CAAC,EAAE,SAAS,OAAO,MAAM,CAAC;AAAA,EACjE,IACA;AAEN,QAAM,mBAAmB,cAAc,OAAO;AAC9C,QAAM,2BAA2B,cAAc,qBAAqB;AAEpE,QAAM,mBACJ,eAAe,WACX,kFACA,eAAe,cACb,8HACA;AAsBR,iBAAe;AAAA;AACf,iBAAe;AAAA,EAAmD,sBAAsB;AAAA;AAAA;AAAA;AACxF,iBAAe,4BAA4B,gBAAgB;AAAA;AAC3D,iBAAe,4BAA4B,wBAAwB;AAAA;AACnE,iBAAe;AAAA;AACf,iBAAe;AAAA;AACf,iBAAe,KAAK,gBAAgB;AAAA;AACpC,iBAAe;AAEf,SAAO;AACT;AAKO,MAAM,2BAA2B,OACtC,oBAAgB,gCAAiB,MAC9B;AACH,QAAM,EAAE,uBAAuB,SAAS,IAAI,cAAc;AAG1D,YAAM,uBAAM,uBAAuB,EAAE,WAAW,KAAK,CAAC;AAEtD,QAAM,+BAAyC,iBAAAC,QAAG;AAAA,QAChD,6BAAc,GAAG,QAAQ,OAAO;AAAA,IAChC;AAAA,MACE,QAAQ,CAAC,WAAW;AAAA,IACtB;AAAA,EACF;AAGA,QAAM,YAAY,yBAAyB,4BAA4B;AACvE,YAAM,+BAAU,kBAAK,uBAAuB,eAAe,GAAG,SAAS;AACzE;","names":["locale","fg"]}

package/dist/cjs/transpiler/dictionary_to_type/createType.cjs

@@ -23,8 +23,9 @@ __export(createType_exports, {
 });
 module.exports = __toCommonJS(createType_exports);
 var import_config = require("@intlayer/config");
-var import_fs = require("fs");
+var import_promises = require("fs/promises");
 var import_path = require("path");
+var import_parallelize = require('../../utils/parallelize.cjs');
 const requireUncached = (module2) => {
   delete import_config.ESMxCJSRequire.cache[import_config.ESMxCJSRequire.resolve(module2)];
   return (0, import_config.ESMxCJSRequire)(module2);
@@ -35,23 +36,23 @@ const generateTypeScriptType = (dictionary) => {
 export default ${jsonString} as const;
 `;
 };
-const createTypes = (dictionariesPaths, configuration = (0, import_config.getConfiguration)()) => {
+const createTypes = async (dictionariesPaths, configuration = (0, import_config.getConfiguration)()) => {
   const { typesDir } = configuration.content;
-  const resultTypesPaths = [];
-  if (!(0, import_fs.existsSync)(typesDir)) {
-    (0, import_fs.mkdirSync)(typesDir, { recursive: true });
-  }
-  for (const dictionaryPath of dictionariesPaths) {
-    const dictionary = requireUncached(dictionaryPath);
-    if (!dictionary.key) {
-      continue;
+  await (0, import_promises.mkdir)(typesDir, { recursive: true });
+  const results = await (0, import_parallelize.parallelize)(
+    dictionariesPaths,
+    async (dictionaryPath) => {
+      const dictionary = requireUncached(dictionaryPath);
+      if (!dictionary.key) {
+        return void 0;
+      }
+      const typeDefinition = generateTypeScriptType(dictionary);
+      const outputPath = (0, import_path.resolve)(typesDir, `${dictionary.key}.ts`);
+      await (0, import_promises.writeFile)(outputPath, typeDefinition);
+      return outputPath;
     }
-    const typeDefinition = generateTypeScriptType(dictionary);
-    const outputPath = (0, import_path.resolve)(typesDir, `${dictionary.key}.ts`);
-    (0, import_fs.writeFileSync)(outputPath, typeDefinition);
-    resultTypesPaths.push(outputPath);
-  }
-  return resultTypesPaths;
+  );
+  return results.filter(Boolean);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/transpiler/dictionary_to_type/createType.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/transpiler/dictionary_to_type/createType.ts"],"sourcesContent":["import {\n  ESMxCJSRequire,\n  getConfiguration,\n  IntlayerConfig,\n} from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport { existsSync, mkdirSync, writeFileSync } from 'fs';\nimport { resolve } from 'path';\n\nconst requireUncached = (module: string) => {\n  delete ESMxCJSRequire.cache[ESMxCJSRequire.resolve(module)];\n  return ESMxCJSRequire(module);\n};\n\nexport const generateTypeScriptType = (dictionary: Dictionary) => {\n  const jsonString = JSON.stringify(dictionary, null, 2);\n\n  return `/* eslint-disable */\\nexport default ${jsonString} as const;\\n`;\n};\n/**\n * This function generates a TypeScript type definition from a JSON object\n */\nexport const createTypes = (\n  dictionariesPaths: string[],\n  configuration: IntlayerConfig = getConfiguration()\n): string[] => {\n  const { typesDir } = configuration.content;\n  const resultTypesPaths: string[] = [];\n\n  // Create type folders if they don't exist\n  if (!existsSync(typesDir)) {\n    mkdirSync(typesDir, { recursive: true });\n  }\n\n  for (const dictionaryPath of dictionariesPaths) {\n    const dictionary: Dictionary = requireUncached(dictionaryPath);\n\n    if (!dictionary.key) {\n      // Skip dictionary if it doesn't have a key, if not exported as default etc\n      continue;\n    }\n\n    const typeDefinition: string = generateTypeScriptType(dictionary);\n\n    const outputPath: string = resolve(typesDir, `${dictionary.key}.ts`);\n\n    writeFileSync(outputPath, typeDefinition);\n\n    resultTypesPaths.push(outputPath);\n  }\n\n  return resultTypesPaths;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAIO;AAEP,gBAAqD;AACrD,kBAAwB;AAExB,MAAM,kBAAkB,CAACA,YAAmB;AAC1C,SAAO,6BAAe,MAAM,6BAAe,QAAQA,OAAM,CAAC;AAC1D,aAAO,8BAAeA,OAAM;AAC9B;AAEO,MAAM,yBAAyB,CAAC,eAA2B;AAChE,QAAM,aAAa,KAAK,UAAU,YAAY,MAAM,CAAC;AAErD,SAAO;AAAA,iBAAwC,UAAU;AAAA;AAC3D;AAIO,MAAM,cAAc,CACzB,mBACA,oBAAgC,gCAAiB,MACpC;AACb,QAAM,EAAE,SAAS,IAAI,cAAc;AACnC,QAAM,mBAA6B,CAAC;AAGpC,MAAI,KAAC,sBAAW,QAAQ,GAAG;AACzB,6BAAU,UAAU,EAAE,WAAW,KAAK,CAAC;AAAA,EACzC;AAEA,aAAW,kBAAkB,mBAAmB;AAC9C,UAAM,aAAyB,gBAAgB,cAAc;AAE7D,QAAI,CAAC,WAAW,KAAK;AAEnB;AAAA,IACF;AAEA,UAAM,iBAAyB,uBAAuB,UAAU;AAEhE,UAAM,iBAAqB,qBAAQ,UAAU,GAAG,WAAW,GAAG,KAAK;AAEnE,iCAAc,YAAY,cAAc;AAExC,qBAAiB,KAAK,UAAU;AAAA,EAClC;AAEA,SAAO;AACT;","names":["module"]}
+{"version":3,"sources":["../../../../src/transpiler/dictionary_to_type/createType.ts"],"sourcesContent":["import {\n  ESMxCJSRequire,\n  getConfiguration,\n  IntlayerConfig,\n} from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport { mkdir, writeFile } from 'fs/promises';\nimport { resolve } from 'path';\nimport { parallelize } from '../../utils/parallelize';\n\nconst requireUncached = (module: string) => {\n  delete ESMxCJSRequire.cache[ESMxCJSRequire.resolve(module)];\n  return ESMxCJSRequire(module);\n};\n\nexport const generateTypeScriptType = (dictionary: Dictionary) => {\n  const jsonString = JSON.stringify(dictionary, null, 2);\n\n  return `/* eslint-disable */\\nexport default ${jsonString} as const;\\n`;\n};\n/**\n * This function generates a TypeScript type definition from a JSON object\n */\nexport const createTypes = async (\n  dictionariesPaths: string[],\n  configuration: IntlayerConfig = getConfiguration()\n): Promise<string[]> => {\n  const { typesDir } = configuration.content;\n\n  // Create type folders if they don't exist\n  await mkdir(typesDir, { recursive: true });\n\n  const results = await parallelize(\n    dictionariesPaths,\n    async (dictionaryPath): Promise<string | undefined> => {\n      const dictionary: Dictionary = requireUncached(dictionaryPath);\n\n      if (!dictionary.key) {\n        return undefined;\n      }\n\n      const typeDefinition: string = generateTypeScriptType(dictionary);\n\n      const outputPath: string = resolve(typesDir, `${dictionary.key}.ts`);\n\n      await writeFile(outputPath, typeDefinition);\n\n      return outputPath;\n    }\n  );\n\n  return results.filter(Boolean) as string[];\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAIO;AAEP,sBAAiC;AACjC,kBAAwB;AACxB,yBAA4B;AAE5B,MAAM,kBAAkB,CAACA,YAAmB;AAC1C,SAAO,6BAAe,MAAM,6BAAe,QAAQA,OAAM,CAAC;AAC1D,aAAO,8BAAeA,OAAM;AAC9B;AAEO,MAAM,yBAAyB,CAAC,eAA2B;AAChE,QAAM,aAAa,KAAK,UAAU,YAAY,MAAM,CAAC;AAErD,SAAO;AAAA,iBAAwC,UAAU;AAAA;AAC3D;AAIO,MAAM,cAAc,OACzB,mBACA,oBAAgC,gCAAiB,MAC3B;AACtB,QAAM,EAAE,SAAS,IAAI,cAAc;AAGnC,YAAM,uBAAM,UAAU,EAAE,WAAW,KAAK,CAAC;AAEzC,QAAM,UAAU,UAAM;AAAA,IACpB;AAAA,IACA,OAAO,mBAAgD;AACrD,YAAM,aAAyB,gBAAgB,cAAc;AAE7D,UAAI,CAAC,WAAW,KAAK;AACnB,eAAO;AAAA,MACT;AAEA,YAAM,iBAAyB,uBAAuB,UAAU;AAEhE,YAAM,iBAAqB,qBAAQ,UAAU,GAAG,WAAW,GAAG,KAAK;AAEnE,gBAAM,2BAAU,YAAY,cAAc;AAE1C,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO,QAAQ,OAAO,OAAO;AAC/B;","names":["module"]}

package/dist/cjs/utils/formatter.cjs

@@ -0,0 +1,50 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var formatter_exports = {};
+__export(formatter_exports, {
+  formatLocale: () => formatLocale,
+  formatPath: () => formatPath
+});
+module.exports = __toCommonJS(formatter_exports);
+var import_config = require("@intlayer/config");
+var import_built = __toESM(require("@intlayer/config/built"));
+var import_core = require("@intlayer/core");
+var import_path = require("path");
+const formatPath = (path, color) => [path].flat().map(
+  (path2) => path2.startsWith("/") ? (0, import_path.relative)(import_built.default.content.baseDir, path2) : path2
+).map(
+  (relativePath) => color === false ? relativePath : (0, import_config.colorizePath)(relativePath, color)
+).join(`, `);
+const formatLocale = (locale, color = import_config.ANSIColors.GREEN) => [locale].flat().map((locale2) => `${(0, import_core.getLocaleName)(locale2, import_config.Locales.ENGLISH)} (${locale2})`).map((text) => color === false ? text : (0, import_config.colorize)(text, color)).join(`, `);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatLocale,
+  formatPath
+});
+//# sourceMappingURL=formatter.cjs.map

package/dist/cjs/utils/formatter.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/formatter.ts"],"sourcesContent":["import { ANSIColors, colorize, colorizePath, Locales } from '@intlayer/config';\nimport configuration from '@intlayer/config/built';\nimport { getLocaleName } from '@intlayer/core';\nimport { relative } from 'path';\n\nexport const formatPath = (\n  path: string | string[],\n  color?: ANSIColors | false\n) =>\n  [path]\n    .flat()\n    .map((path) =>\n      path.startsWith('/')\n        ? relative(configuration.content.baseDir, path)\n        : path\n    )\n    .map((relativePath) =>\n      color === false ? relativePath : colorizePath(relativePath, color)\n    )\n    .join(`, `);\n\nexport const formatLocale = (\n  locale: Locales | Locales[],\n  color: ANSIColors | false = ANSIColors.GREEN\n) =>\n  [locale]\n    .flat()\n    .map((locale) => `${getLocaleName(locale, Locales.ENGLISH)} (${locale})`)\n    .map((text) => (color === false ? text : colorize(text, color)))\n    .join(`, `);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA4D;AAC5D,mBAA0B;AAC1B,kBAA8B;AAC9B,kBAAyB;AAElB,MAAM,aAAa,CACxB,MACA,UAEA,CAAC,IAAI,EACF,KAAK,EACL;AAAA,EAAI,CAACA,UACJA,MAAK,WAAW,GAAG,QACf,sBAAS,aAAAC,QAAc,QAAQ,SAASD,KAAI,IAC5CA;AACN,EACC;AAAA,EAAI,CAAC,iBACJ,UAAU,QAAQ,mBAAe,4BAAa,cAAc,KAAK;AACnE,EACC,KAAK,IAAI;AAEP,MAAM,eAAe,CAC1B,QACA,QAA4B,yBAAW,UAEvC,CAAC,MAAM,EACJ,KAAK,EACL,IAAI,CAACE,YAAW,OAAG,2BAAcA,SAAQ,sBAAQ,OAAO,CAAC,KAAKA,OAAM,GAAG,EACvE,IAAI,CAAC,SAAU,UAAU,QAAQ,WAAO,wBAAS,MAAM,KAAK,CAAE,EAC9D,KAAK,IAAI;","names":["path","configuration","locale"]}