@intlayer/chokidar 5.8.1 → 6.0.0-canary.1

package/dist/esm/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeMergedDictionary.mjs.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,SAAS,wBAAwB;AAEjC,SAAS,OAAO,iBAAiB;AACjC,SAAS,eAAe;AACxB,SAAS,yBAAyB;AAClC,SAAS,kCAAkC;AAC3C,SAAS,4BAA4B;AA0B9B,MAAM,0BAA0B,OACrC,qBACA,gBAAgB,iBAAiB,MACG;AACpC,QAAM,EAAE,gBAAgB,IAAI,cAAc;AAG1C,QAAM,MAAM,QAAQ,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,eAAe,2BAA2B,UAAU;AAAA,IACvD;AAEA,UAAM,mBAAmB,kBAAkB,uBAAuB;AAElE,UAAM,gBAAgB,qBAAqB,gBAAgB;AAE3D,UAAM,iBAAiB,GAAG,GAAG;AAC7B,UAAM,iBAAiB,QAAQ,iBAAiB,cAAc;AAG9D,UAAM,UAAU,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,SAAS,wBAAwB;AAEjC,SAAS,OAAO,iBAAiB;AACjC,SAAS,eAAe;AACxB,SAAS,yBAAyB;AAClC,SAAS,kCAAkC;AAC3C,SAAS,mBAAmB;AAC5B,SAAS,4BAA4B;AA0B9B,MAAM,0BAA0B,OACrC,qBACA,gBAAgB,iBAAiB,MACG;AACpC,QAAM,EAAE,gBAAgB,IAAI,cAAc;AAG1C,QAAM,MAAM,QAAQ,eAAe,GAAG,EAAE,WAAW,KAAK,CAAC;AAEzD,QAAM,UAAU,MAAM;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,eAAe,2BAA2B,UAAU;AAAA,MACvD;AAEA,YAAM,mBAAmB,kBAAkB,uBAAuB;AAElE,YAAM,gBAAgB,qBAAqB,gBAAgB;AAE3D,YAAM,iBAAiB,GAAG,GAAG;AAC7B,YAAM,iBAAiB,QAAQ,iBAAiB,cAAc;AAG9D,YAAM,UAAU,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/esm/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeRemoteDictionary.mjs

@@ -0,0 +1,28 @@
+import { getConfiguration } from "@intlayer/config";
+import { mkdir, writeFile } from "fs/promises";
+import { resolve } from "path";
+import { filterInvalidDictionaries } from "../../../filterInvalidDictionaries.mjs";
+import { formatDistantDictionaries } from "../../../loadDictionaries/index.mjs";
+import { parallelize } from "../../../utils/parallelize.mjs";
+import { formatDictionaryText } from "./formatDictionaryText.mjs";
+const writeRemoteDictionary = async (remoteDictionaries, configuration = getConfiguration()) => {
+  const { remoteDictionariesDir } = configuration.content;
+  await mkdir(resolve(remoteDictionariesDir), { recursive: true });
+  const filteredDictionaries = filterInvalidDictionaries(remoteDictionaries);
+  await parallelize(
+    filteredDictionaries.filter((dictionary) => dictionary.key !== "undefined"),
+    async (dictionary) => {
+      const outputFileName = `${dictionary.key}.json`;
+      const resultFilePath = resolve(remoteDictionariesDir, outputFileName);
+      const contentString = formatDictionaryText(dictionary);
+      await writeFile(resultFilePath, contentString, "utf8").catch((err) => {
+        console.error(`Error creating merged ${outputFileName}:`, err);
+      });
+    }
+  );
+  return formatDistantDictionaries(remoteDictionaries);
+};
+export {
+  writeRemoteDictionary
+};
+//# sourceMappingURL=writeRemoteDictionary.mjs.map

package/dist/esm/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeRemoteDictionary.mjs.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,SAAS,wBAAwB;AAEjC,SAAS,OAAO,iBAAiB;AACjC,SAAS,eAAe;AACxB,SAAS,iCAAiC;AAC1C,SAAS,iCAAiC;AAC1C,SAAS,mBAAmB;AAC5B,SAAS,4BAA4B;AAkB9B,MAAM,wBAAwB,OACnC,oBACA,gBAAgB,iBAAiB,MACP;AAC1B,QAAM,EAAE,sBAAsB,IAAI,cAAc;AAGhD,QAAM,MAAM,QAAQ,qBAAqB,GAAG,EAAE,WAAW,KAAK,CAAC;AAE/D,QAAM,uBAAuB,0BAA0B,kBAAkB;AAGzE,QAAM;AAAA,IACJ,qBAAqB,OAAO,CAAC,eAAe,WAAW,QAAQ,WAAW;AAAA,IAC1E,OAAO,eAAe;AACpB,YAAM,iBAAiB,GAAG,WAAW,GAAG;AACxC,YAAM,iBAAiB,QAAQ,uBAAuB,cAAc;AAEpE,YAAM,gBAAgB,qBAAqB,UAAU;AAGrD,YAAM,UAAU,gBAAgB,eAAe,MAAM,EAAE,MAAM,CAAC,QAAQ;AACpE,gBAAQ,MAAM,yBAAyB,cAAc,KAAK,GAAG;AAAA,MAC/D,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO,0BAA0B,kBAAkB;AACrD;","names":[]}

package/dist/esm/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeUnmergedDictionary.mjs

@@ -1,39 +1,54 @@
-import { getConfiguration } from "@intlayer/config";
+import { getConfiguration, x } from "@intlayer/config";
 import { mkdir, writeFile } from "fs/promises";
 import { resolve } from "path";
+import { filterInvalidDictionaries } from "../../../filterInvalidDictionaries.mjs";
+import { orderDictionaries } from "../../../orderDictionaries.mjs";
+import { parallelize } from "../../../utils/parallelize.mjs";
 import { formatDictionaryText } from "./formatDictionaryText.mjs";
-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 = getConfiguration()) => {
   const { unmergedDictionariesDir } = configuration.content;
   await mkdir(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 = formatDictionaryText(dictionaries2);
-    const outputFileName = `${key}.json`;
-    const unmergedFilePath = resolve(unmergedDictionariesDir, outputFileName);
-    await writeFile(unmergedFilePath, contentString, "utf8").catch((err) => {
-      console.error(`Error creating unmerged ${outputFileName}:`, err);
-    });
-    resultDictionariesPaths[key] = {
-      dictionaryPath: unmergedFilePath,
-      dictionaries: dictionaries2
-    };
-  }
-  return resultDictionariesPaths;
+  const filteredDictionaries = filterInvalidDictionaries(dictionaries);
+  const groupedDictionaries = groupDictionariesByKey(filteredDictionaries);
+  const results = await parallelize(
+    Object.entries(groupedDictionaries),
+    async ([key, dictionaries2]) => {
+      if (key === "undefined") {
+        return void 0;
+      }
+      const orderedDictionaries = orderDictionaries(
+        dictionaries2,
+        configuration
+      );
+      const contentString = formatDictionaryText(orderedDictionaries);
+      const outputFileName = `${key}.json`;
+      const unmergedFilePath = resolve(unmergedDictionariesDir, outputFileName);
+      await writeFile(unmergedFilePath, contentString, "utf8").catch((err) => {
+        console.error(`${x} Error creating unmerged ${outputFileName}:`, err);
+      });
+      return [
+        key,
+        {
+          dictionaryPath: unmergedFilePath,
+          dictionaries: dictionaries2
+        }
+      ];
+    }
+  );
+  return Object.fromEntries(
+    results.filter(Boolean)
+  );
 };
 export {
   writeUnmergedDictionaries

package/dist/esm/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeUnmergedDictionary.mjs.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,SAAS,wBAAwB;AAEjC,SAAS,OAAO,iBAAiB;AACjC,SAAS,eAAe;AACxB,SAAS,4BAA4B;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,gBAAgB,iBAAiB,MACK;AACtC,QAAM,EAAE,wBAAwB,IAAI,cAAc;AAGlD,QAAM,MAAM,QAAQ,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,gBAAgB,qBAAqBA,aAAY;AAEvD,UAAM,iBAAiB,GAAG,GAAG;AAC7B,UAAM,mBAAmB,QAAQ,yBAAyB,cAAc;AAGxE,UAAM,UAAU,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,SAAS,kBAAkB,SAAS;AAEpC,SAAS,OAAO,iBAAiB;AACjC,SAAS,eAAe;AACxB,SAAS,iCAAiC;AAC1C,SAAS,yBAAyB;AAClC,SAAS,mBAAmB;AAC5B,SAAS,4BAA4B;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,gBAAgB,iBAAiB,MACK;AACtC,QAAM,EAAE,wBAAwB,IAAI,cAAc;AAGlD,QAAM,MAAM,QAAQ,uBAAuB,GAAG,EAAE,WAAW,KAAK,CAAC;AAEjE,QAAM,uBAAuB,0BAA0B,YAAY;AAGnE,QAAM,sBAAsB,uBAAuB,oBAAoB;AAEvE,QAAM,UAAU,MAAM;AAAA,IACpB,OAAO,QAAQ,mBAAmB;AAAA,IAClC,OAAO,CAAC,KAAKA,aAAY,MAAM;AAC7B,UAAI,QAAQ,aAAa;AACvB,eAAO;AAAA,MAIT;AAEA,YAAM,sBAAsB;AAAA,QAC1BA;AAAA,QACA;AAAA,MACF;AACA,YAAM,gBAAgB,qBAAqB,mBAAmB;AAE9D,YAAM,iBAAiB,GAAG,GAAG;AAC7B,YAAM,mBAAmB,QAAQ,yBAAyB,cAAc;AAGxE,YAAM,UAAU,kBAAkB,eAAe,MAAM,EAAE,MAAM,CAAC,QAAQ;AACtE,gBAAQ,MAAM,GAAG,CAAC,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/esm/transpiler/dictionary_to_main/createDictionaryEntryPoint.mjs

@@ -1,9 +1,12 @@
 import { getConfiguration } from "@intlayer/config";
-import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { mkdir, writeFile } from "fs/promises";
 import { resolve } from "path";
 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 { parallelize } from "../../utils/parallelize.mjs";
 import { generateDictionaryListContent } from "./generateDictionaryListContent.mjs";
 const filterDictionaries = (paths, keys) => {
   if (!keys) return paths;
@@ -11,50 +14,52 @@ const filterDictionaries = (paths, keys) => {
     (path) => keys.some((key) => path.endsWith(`${key}.json`))
   );
 };
-const writeDictionaryFiles = (paths, fileName, format, configuration = getConfiguration()) => {
+const writeDictionaryFiles = async (paths, fileName, format, configuration = getConfiguration()) => {
   const content = generateDictionaryListContent(paths, format, configuration);
   const extension = format === "cjs" ? "cjs" : "mjs";
   const { mainDir } = configuration.content;
-  writeFileSync(resolve(mainDir, `${fileName}.${extension}`), content);
+  await writeFile(resolve(mainDir, `${fileName}.${extension}`), content);
 };
-const createDictionaryEntryPoint = (configuration = getConfiguration(), dictionariesKeys, formats = ["cjs", "esm"]) => {
+const createDictionaryEntryPoint = async (configuration = getConfiguration(), dictionariesKeys, formats = ["cjs", "esm"]) => {
   const { mainDir } = configuration.content;
-  if (!existsSync(mainDir)) {
-    mkdirSync(mainDir, { recursive: true });
-  }
+  await mkdir(mainDir, { recursive: true });
+  const remoteDictionariesPath = getBuiltRemoteDictionariesPath(configuration);
   const dictionariesPath = filterDictionaries(
     getBuiltDictionariesPath(configuration),
     dictionariesKeys
   );
-  for (const format of formats) {
-    writeDictionaryFiles(
-      dictionariesPath,
-      "dictionaries",
-      format,
-      configuration
-    );
-  }
   const unmergedDictionariesPath = getBuiltUnmergedDictionariesPath(configuration);
-  for (const format of formats) {
-    writeDictionaryFiles(
-      unmergedDictionariesPath,
-      "unmerged_dictionaries",
-      format,
-      configuration
-    );
-  }
-  for (const format of formats) {
-    const dynamicDictionariesPathCJS = 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: getBuiltDynamicDictionariesPath(configuration, format),
+      fileName: "dynamic_dictionaries",
+      format
+    })),
+    ...formats.map((format) => ({
+      paths: getBuiltFetchDictionariesPath(configuration, format),
+      fileName: "fetch_dictionaries",
+      format
+    }))
+  ];
+  await parallelize(
+    writeOperations,
+    async ({ paths, fileName, format }) => writeDictionaryFiles(paths, fileName, format, configuration)
+  );
 };
 export {
   createDictionaryEntryPoint

package/dist/esm/transpiler/dictionary_to_main/createDictionaryEntryPoint.mjs.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,SAAS,wBAAwB;AACjC,SAAS,YAAY,WAAW,qBAAqB;AACrD,SAAS,eAAe;AACxB,SAAS,gCAAgC;AACzC,SAAS,uCAAuC;AAChD,SAAS,wCAAwC;AACjD,SAAS,qCAAqC;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,gBAAgB,iBAAiB,MAC9B;AACH,QAAM,UAAU,8BAA8B,OAAO,QAAQ,aAAa;AAC1E,QAAM,YAAY,WAAW,QAAQ,QAAQ;AAE7C,QAAM,EAAE,QAAQ,IAAI,cAAc;AAElC,gBAAc,QAAQ,SAAS,GAAG,QAAQ,IAAI,SAAS,EAAE,GAAG,OAAO;AACrE;AAKO,MAAM,6BAA6B,CACxC,gBAAgB,iBAAiB,GACjC,kBACA,UAA6B,CAAC,OAAO,KAAK,MACvC;AACH,QAAM,EAAE,QAAQ,IAAI,cAAc;AAGlC,MAAI,CAAC,WAAW,OAAO,GAAG;AACxB,cAAU,SAAS,EAAE,WAAW,KAAK,CAAC;AAAA,EACxC;AAEA,QAAM,mBAAmB;AAAA,IACvB,yBAAyB,aAAa;AAAA,IACtC;AAAA,EACF;AAEA,aAAW,UAAU,SAAS;AAC5B;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,QAAM,2BACJ,iCAAiC,aAAa;AAEhD,aAAW,UAAU,SAAS;AAC5B;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,aAAW,UAAU,SAAS;AAC5B,UAAM,6BAA6B;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,SAAS,wBAAwB;AACjC,SAAS,OAAO,iBAAiB;AACjC,SAAS,eAAe;AACxB,SAAS,gCAAgC;AACzC,SAAS,uCAAuC;AAChD,SAAS,qCAAqC;AAC9C,SAAS,sCAAsC;AAC/C,SAAS,wCAAwC;AACjD,SAAS,mBAAmB;AAC5B,SAAS,qCAAqC;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,gBAAgB,iBAAiB,MAC9B;AACH,QAAM,UAAU,8BAA8B,OAAO,QAAQ,aAAa;AAC1E,QAAM,YAAY,WAAW,QAAQ,QAAQ;AAE7C,QAAM,EAAE,QAAQ,IAAI,cAAc;AAElC,QAAM,UAAU,QAAQ,SAAS,GAAG,QAAQ,IAAI,SAAS,EAAE,GAAG,OAAO;AACvE;AAKO,MAAM,6BAA6B,OACxC,gBAAgB,iBAAiB,GACjC,kBACA,UAA6B,CAAC,OAAO,KAAK,MACvC;AACH,QAAM,EAAE,QAAQ,IAAI,cAAc;AAElC,QAAM,MAAM,SAAS,EAAE,WAAW,KAAK,CAAC;AAExC,QAAM,yBAAyB,+BAA+B,aAAa;AAC3E,QAAM,mBAAmB;AAAA,IACvB,yBAAyB,aAAa;AAAA,IACtC;AAAA,EACF;AACA,QAAM,2BACJ,iCAAiC,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,OAAO,gCAAgC,eAAe,MAAM;AAAA,MAC5D,UAAU;AAAA,MACV;AAAA,IACF,EAAE;AAAA,IACF,GAAG,QAAQ,IAAI,CAAC,YAAY;AAAA,MAC1B,OAAO,8BAA8B,eAAe,MAAM;AAAA,MAC1D,UAAU;AAAA,MACV;AAAA,IACF,EAAE;AAAA,EACJ;AAEA,QAAM;AAAA,IAAY;AAAA,IAAiB,OAAO,EAAE,OAAO,UAAU,OAAO,MAClE,qBAAqB,OAAO,UAAU,QAAQ,aAAa;AAAA,EAC7D;AACF;","names":[]}

package/dist/esm/transpiler/dictionary_to_type/createModuleAugmentation.mjs

@@ -1,6 +1,6 @@
 import { Locales, getConfiguration, normalizePath } from "@intlayer/config";
 import fg from "fast-glob";
-import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { mkdir, writeFile } from "fs/promises";
 import { basename, extname, join, relative } from "path";
 import { getFileHash } from "../../utils/getFileHash.mjs";
 import { kebabCaseToCamelCase } from "../../utils/kebabCaseToCamelCase.mjs";
@@ -56,11 +56,9 @@ ${formattedDictionaryMap}
   fileContent += `}`;
   return fileContent;
 };
-const createModuleAugmentation = (configuration = getConfiguration()) => {
+const createModuleAugmentation = async (configuration = getConfiguration()) => {
   const { moduleAugmentationDir, typesDir } = configuration.content;
-  if (!existsSync(moduleAugmentationDir)) {
-    mkdirSync(moduleAugmentationDir, { recursive: true });
-  }
+  await mkdir(moduleAugmentationDir, { recursive: true });
   const dictionariesTypesDefinitions = fg.sync(
     normalizePath(`${typesDir}/*.ts`),
     {
@@ -68,7 +66,7 @@ const createModuleAugmentation = (configuration = getConfiguration()) => {
     }
   );
   const tsContent = generateTypeIndexContent(dictionariesTypesDefinitions);
-  writeFileSync(join(moduleAugmentationDir, "intlayer.d.ts"), tsContent);
+  await writeFile(join(moduleAugmentationDir, "intlayer.d.ts"), tsContent);
 };
 export {
   createModuleAugmentation,

package/dist/esm/transpiler/dictionary_to_type/createModuleAugmentation.mjs.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,SAAS,SAAS,kBAAkB,qBAAqB;AACzD,OAAO,QAAQ;AACf,SAAS,YAAY,WAAW,qBAAqB;AACrD,SAAS,UAAU,SAAS,MAAM,gBAAgB;AAClD,SAAS,mBAAmB;AAC5B,SAAS,4BAA4B;AAE9B,MAAM,cAAc,CAAC,QAC1B,GAAG,qBAAqB,GAAG,CAAC;AAE9B,MAAM,gBAAgB,CAAC,YACrB,QACG,IAAI,CAAC,WAAW;AACf,aAAW,OAAO,SAAS;AACzB,QAAI,QAAQ,GAA2B,MAAM,QAAQ;AACnD,aAAO,WAAW,GAAG;AAAA,IACvB;AAAA,EACF;AACF,CAAC,EACA,KAAK,KAAK;AAKf,MAAM,2BAA2B,CAC/B,WACA,gBAAgB,iBAAiB,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,KAAK,SAAS,uBAAuB,cAAc,CAAC;AAAA,IAClE,IAAI,SAAS,gBAAgB,QAAQ,cAAc,CAAC;AAAA;AAAA,IACpD,MAAM,IAAI,YAAY,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,gBAAgB,iBAAiB,MAC9B;AACH,QAAM,EAAE,uBAAuB,SAAS,IAAI,cAAc;AAG1D,MAAI,CAAC,WAAW,qBAAqB,GAAG;AACtC,cAAU,uBAAuB,EAAE,WAAW,KAAK,CAAC;AAAA,EACtD;AAEA,QAAM,+BAAyC,GAAG;AAAA,IAChD,cAAc,GAAG,QAAQ,OAAO;AAAA,IAChC;AAAA,MACE,QAAQ,CAAC,WAAW;AAAA,IACtB;AAAA,EACF;AAGA,QAAM,YAAY,yBAAyB,4BAA4B;AACvE,gBAAc,KAAK,uBAAuB,eAAe,GAAG,SAAS;AACvE;","names":["locale"]}
+{"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,SAAS,SAAS,kBAAkB,qBAAqB;AACzD,OAAO,QAAQ;AACf,SAAS,OAAO,iBAAiB;AACjC,SAAS,UAAU,SAAS,MAAM,gBAAgB;AAClD,SAAS,mBAAmB;AAC5B,SAAS,4BAA4B;AAE9B,MAAM,cAAc,CAAC,QAC1B,GAAG,qBAAqB,GAAG,CAAC;AAE9B,MAAM,gBAAgB,CAAC,YACrB,QACG,IAAI,CAAC,WAAW;AACf,aAAW,OAAO,SAAS;AACzB,QAAI,QAAQ,GAA2B,MAAM,QAAQ;AACnD,aAAO,WAAW,GAAG;AAAA,IACvB;AAAA,EACF;AACF,CAAC,EACA,KAAK,KAAK;AAKf,MAAM,2BAA2B,CAC/B,WACA,gBAAgB,iBAAiB,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,KAAK,SAAS,uBAAuB,cAAc,CAAC;AAAA,IAClE,IAAI,SAAS,gBAAgB,QAAQ,cAAc,CAAC;AAAA;AAAA,IACpD,MAAM,IAAI,YAAY,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,gBAAgB,iBAAiB,MAC9B;AACH,QAAM,EAAE,uBAAuB,SAAS,IAAI,cAAc;AAG1D,QAAM,MAAM,uBAAuB,EAAE,WAAW,KAAK,CAAC;AAEtD,QAAM,+BAAyC,GAAG;AAAA,IAChD,cAAc,GAAG,QAAQ,OAAO;AAAA,IAChC;AAAA,MACE,QAAQ,CAAC,WAAW;AAAA,IACtB;AAAA,EACF;AAGA,QAAM,YAAY,yBAAyB,4BAA4B;AACvE,QAAM,UAAU,KAAK,uBAAuB,eAAe,GAAG,SAAS;AACzE;","names":["locale"]}

package/dist/esm/transpiler/dictionary_to_type/createType.mjs

@@ -2,8 +2,9 @@ import {
   ESMxCJSRequire,
   getConfiguration
 } from "@intlayer/config";
-import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { mkdir, writeFile } from "fs/promises";
 import { resolve } from "path";
+import { parallelize } from "../../utils/parallelize.mjs";
 const requireUncached = (module) => {
   delete ESMxCJSRequire.cache[ESMxCJSRequire.resolve(module)];
   return ESMxCJSRequire(module);
@@ -14,23 +15,23 @@ const generateTypeScriptType = (dictionary) => {
 export default ${jsonString} as const;
 `;
 };
-const createTypes = (dictionariesPaths, configuration = getConfiguration()) => {
+const createTypes = async (dictionariesPaths, configuration = getConfiguration()) => {
   const { typesDir } = configuration.content;
-  const resultTypesPaths = [];
-  if (!existsSync(typesDir)) {
-    mkdirSync(typesDir, { recursive: true });
-  }
-  for (const dictionaryPath of dictionariesPaths) {
-    const dictionary = requireUncached(dictionaryPath);
-    if (!dictionary.key) {
-      continue;
+  await mkdir(typesDir, { recursive: true });
+  const results = await parallelize(
+    dictionariesPaths,
+    async (dictionaryPath) => {
+      const dictionary = requireUncached(dictionaryPath);
+      if (!dictionary.key) {
+        return void 0;
+      }
+      const typeDefinition = generateTypeScriptType(dictionary);
+      const outputPath = resolve(typesDir, `${dictionary.key}.ts`);
+      await writeFile(outputPath, typeDefinition);
+      return outputPath;
     }
-    const typeDefinition = generateTypeScriptType(dictionary);
-    const outputPath = resolve(typesDir, `${dictionary.key}.ts`);
-    writeFileSync(outputPath, typeDefinition);
-    resultTypesPaths.push(outputPath);
-  }
-  return resultTypesPaths;
+  );
+  return results.filter(Boolean);
 };
 export {
   createTypes,

package/dist/esm/transpiler/dictionary_to_type/createType.mjs.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,EACE;AAAA,EACA;AAAA,OAEK;AAEP,SAAS,YAAY,WAAW,qBAAqB;AACrD,SAAS,eAAe;AAExB,MAAM,kBAAkB,CAAC,WAAmB;AAC1C,SAAO,eAAe,MAAM,eAAe,QAAQ,MAAM,CAAC;AAC1D,SAAO,eAAe,MAAM;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,gBAAgC,iBAAiB,MACpC;AACb,QAAM,EAAE,SAAS,IAAI,cAAc;AACnC,QAAM,mBAA6B,CAAC;AAGpC,MAAI,CAAC,WAAW,QAAQ,GAAG;AACzB,cAAU,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,aAAqB,QAAQ,UAAU,GAAG,WAAW,GAAG,KAAK;AAEnE,kBAAc,YAAY,cAAc;AAExC,qBAAiB,KAAK,UAAU;AAAA,EAClC;AAEA,SAAO;AACT;","names":[]}
+{"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,EACE;AAAA,EACA;AAAA,OAEK;AAEP,SAAS,OAAO,iBAAiB;AACjC,SAAS,eAAe;AACxB,SAAS,mBAAmB;AAE5B,MAAM,kBAAkB,CAAC,WAAmB;AAC1C,SAAO,eAAe,MAAM,eAAe,QAAQ,MAAM,CAAC;AAC1D,SAAO,eAAe,MAAM;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,gBAAgC,iBAAiB,MAC3B;AACtB,QAAM,EAAE,SAAS,IAAI,cAAc;AAGnC,QAAM,MAAM,UAAU,EAAE,WAAW,KAAK,CAAC;AAEzC,QAAM,UAAU,MAAM;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,aAAqB,QAAQ,UAAU,GAAG,WAAW,GAAG,KAAK;AAEnE,YAAM,UAAU,YAAY,cAAc;AAE1C,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO,QAAQ,OAAO,OAAO;AAC/B;","names":[]}

package/dist/esm/utils/formatter.mjs

@@ -0,0 +1,15 @@
+import { ANSIColors, colorize, colorizePath, Locales } from "@intlayer/config";
+import configuration from "@intlayer/config/built";
+import { getLocaleName } from "@intlayer/core";
+import { relative } from "path";
+const formatPath = (path, color) => [path].flat().map(
+  (path2) => path2.startsWith("/") ? relative(configuration.content.baseDir, path2) : path2
+).map(
+  (relativePath) => color === false ? relativePath : colorizePath(relativePath, color)
+).join(`, `);
+const formatLocale = (locale, color = ANSIColors.GREEN) => [locale].flat().map((locale2) => `${getLocaleName(locale2, Locales.ENGLISH)} (${locale2})`).map((text) => color === false ? text : colorize(text, color)).join(`, `);
+export {
+  formatLocale,
+  formatPath
+};
+//# sourceMappingURL=formatter.mjs.map

package/dist/esm/utils/formatter.mjs.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,SAAS,YAAY,UAAU,cAAc,eAAe;AAC5D,OAAO,mBAAmB;AAC1B,SAAS,qBAAqB;AAC9B,SAAS,gBAAgB;AAElB,MAAM,aAAa,CACxB,MACA,UAEA,CAAC,IAAI,EACF,KAAK,EACL;AAAA,EAAI,CAACA,UACJA,MAAK,WAAW,GAAG,IACf,SAAS,cAAc,QAAQ,SAASA,KAAI,IAC5CA;AACN,EACC;AAAA,EAAI,CAAC,iBACJ,UAAU,QAAQ,eAAe,aAAa,cAAc,KAAK;AACnE,EACC,KAAK,IAAI;AAEP,MAAM,eAAe,CAC1B,QACA,QAA4B,WAAW,UAEvC,CAAC,MAAM,EACJ,KAAK,EACL,IAAI,CAACC,YAAW,GAAG,cAAcA,SAAQ,QAAQ,OAAO,CAAC,KAAKA,OAAM,GAAG,EACvE,IAAI,CAAC,SAAU,UAAU,QAAQ,OAAO,SAAS,MAAM,KAAK,CAAE,EAC9D,KAAK,IAAI;","names":["path","locale"]}

package/dist/esm/utils/parallelize.mjs

@@ -0,0 +1,9 @@
+import pLimit from "p-limit";
+const parallelize = async (items, callback, parallelLimit = 10) => {
+  const limit = pLimit(parallelLimit);
+  return Promise.all(items.map((item) => limit(() => callback(item))));
+};
+export {
+  parallelize
+};
+//# sourceMappingURL=parallelize.mjs.map

package/dist/esm/utils/parallelize.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/parallelize.ts"],"sourcesContent":["import pLimit from 'p-limit';\n\nexport const parallelize = async <T, R>(\n  items: T[],\n  callback: (item: T) => Promise<R>,\n  parallelLimit: number = 10\n): Promise<R[]> => {\n  const limit = pLimit(parallelLimit);\n  return Promise.all(items.map((item) => limit(() => callback(item))));\n};\n"],"mappings":"AAAA,OAAO,YAAY;AAEZ,MAAM,cAAc,OACzB,OACA,UACA,gBAAwB,OACP;AACjB,QAAM,QAAQ,OAAO,aAAa;AAClC,SAAO,QAAQ,IAAI,MAAM,IAAI,CAAC,SAAS,MAAM,MAAM,SAAS,IAAI,CAAC,CAAC,CAAC;AACrE;","names":[]}

package/dist/esm/utils/runOnce.mjs

@@ -1,6 +1,6 @@
 import { mkdir, stat, unlink, writeFile } from "fs/promises";
 import { dirname } from "path";
-const runOnce = async (sentinelFilePath, callback, cacheTimeoutMs = 60 * 1e3) => {
+const runOnce = async (sentinelFilePath, callback, onIsCached, cacheTimeoutMs = 60 * 1e3) => {
   const currentTimestamp = Date.now();
   const timeoutDuration = cacheTimeoutMs;
   try {
@@ -9,6 +9,7 @@ const runOnce = async (sentinelFilePath, callback, cacheTimeoutMs = 60 * 1e3) =>
     if (sentinelAge > timeoutDuration) {
       await unlink(sentinelFilePath);
     } else {
+      await onIsCached?.();
       return;
     }
   } catch (err) {

package/dist/esm/utils/runOnce.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/runOnce.ts"],"sourcesContent":["import { mkdir, stat, unlink, writeFile } from 'fs/promises';\nimport { dirname } from 'path';\n\n/**\n * Ensures a callback function runs only once within a specified time window across multiple processes.\n * Uses a sentinel file to coordinate execution and prevent duplicate work.\n *\n * @param sentinelFilePath - Path to the sentinel file used for coordination\n * @param callback - The function to execute (should be async)\n * @param cacheTimeoutMs - Time window in milliseconds during which the sentinel is considered valid (default: 60000ms = 1 minute)\n *\n * @example\n * ```typescript\n * await runPrepareIntlayerOnce(\n *   '/tmp/intlayer-sentinel',\n *   async () => {\n *     // Your initialization logic here\n *     await prepareIntlayer();\n *   },\n *   30 * 1000 // 30 seconds cache\n * );\n * ```\n *\n * @throws {Error} When there are unexpected filesystem errors\n */\nexport const runOnce = async (\n  sentinelFilePath: string,\n  callback: () => void | Promise<void>,\n  cacheTimeoutMs: number = 60 * 1000 // 1 minute in milliseconds\n) => {\n  const currentTimestamp = Date.now();\n  const timeoutDuration = cacheTimeoutMs;\n\n  try {\n    // Check if sentinel file exists and get its stats\n    const sentinelStats = await stat(sentinelFilePath);\n    const sentinelAge = currentTimestamp - sentinelStats.mtime.getTime();\n\n    // If sentinel is older than the timeout, delete it and rebuild\n    if (sentinelAge > timeoutDuration) {\n      await unlink(sentinelFilePath);\n      // Fall through to create new sentinel and rebuild\n    } else {\n      // Sentinel is recent, no need to rebuild\n      return;\n    }\n  } catch (err: any) {\n    if (err.code === 'ENOENT') {\n      // File doesn't exist, continue to create it\n    } else {\n      throw err; // unexpected FS error\n    }\n  }\n\n  try {\n    // Ensure the directory exists before writing the file\n    await mkdir(dirname(sentinelFilePath), { recursive: true });\n\n    // O_EXCL ensures only the *first* process can create the file\n    await writeFile(sentinelFilePath, String(currentTimestamp), { flag: 'wx' });\n  } catch (err: any) {\n    if (err.code === 'EEXIST') {\n      // Another process already created it → we're done\n      return;\n    }\n    throw err; // unexpected FS error\n  }\n\n  await callback();\n};\n"],"mappings":"AAAA,SAAS,OAAO,MAAM,QAAQ,iBAAiB;AAC/C,SAAS,eAAe;AAwBjB,MAAM,UAAU,OACrB,kBACA,UACA,iBAAyB,KAAK,QAC3B;AACH,QAAM,mBAAmB,KAAK,IAAI;AAClC,QAAM,kBAAkB;AAExB,MAAI;AAEF,UAAM,gBAAgB,MAAM,KAAK,gBAAgB;AACjD,UAAM,cAAc,mBAAmB,cAAc,MAAM,QAAQ;AAGnE,QAAI,cAAc,iBAAiB;AACjC,YAAM,OAAO,gBAAgB;AAAA,IAE/B,OAAO;AAEL;AAAA,IACF;AAAA,EACF,SAAS,KAAU;AACjB,QAAI,IAAI,SAAS,UAAU;AAAA,IAE3B,OAAO;AACL,YAAM;AAAA,IACR;AAAA,EACF;AAEA,MAAI;AAEF,UAAM,MAAM,QAAQ,gBAAgB,GAAG,EAAE,WAAW,KAAK,CAAC;AAG1D,UAAM,UAAU,kBAAkB,OAAO,gBAAgB,GAAG,EAAE,MAAM,KAAK,CAAC;AAAA,EAC5E,SAAS,KAAU;AACjB,QAAI,IAAI,SAAS,UAAU;AAEzB;AAAA,IACF;AACA,UAAM;AAAA,EACR;AAEA,QAAM,SAAS;AACjB;","names":[]}
+{"version":3,"sources":["../../../src/utils/runOnce.ts"],"sourcesContent":["import { mkdir, stat, unlink, writeFile } from 'fs/promises';\nimport { dirname } from 'path';\n\n/**\n * Ensures a callback function runs only once within a specified time window across multiple processes.\n * Uses a sentinel file to coordinate execution and prevent duplicate work.\n *\n * @param sentinelFilePath - Path to the sentinel file used for coordination\n * @param callback - The function to execute (should be async)\n * @param cacheTimeoutMs - Time window in milliseconds during which the sentinel is considered valid (default: 60000ms = 1 minute)\n *\n * @example\n * ```typescript\n * await runPrepareIntlayerOnce(\n *   '/tmp/intlayer-sentinel',\n *   async () => {\n *     // Your initialization logic here\n *     await prepareIntlayer();\n *   },\n *   30 * 1000 // 30 seconds cache\n * );\n * ```\n *\n * @throws {Error} When there are unexpected filesystem errors\n */\nexport const runOnce = async (\n  sentinelFilePath: string,\n  callback: () => void | Promise<void>,\n  onIsCached?: () => void | Promise<void>,\n  cacheTimeoutMs: number = 60 * 1000 // 1 minute in milliseconds\n) => {\n  const currentTimestamp = Date.now();\n  const timeoutDuration = cacheTimeoutMs;\n\n  try {\n    // Check if sentinel file exists and get its stats\n    const sentinelStats = await stat(sentinelFilePath);\n    const sentinelAge = currentTimestamp - sentinelStats.mtime.getTime();\n\n    // If sentinel is older than the timeout, delete it and rebuild\n    if (sentinelAge > timeoutDuration) {\n      await unlink(sentinelFilePath);\n      // Fall through to create new sentinel and rebuild\n    } else {\n      await onIsCached?.();\n      // Sentinel is recent, no need to rebuild\n      return;\n    }\n  } catch (err: any) {\n    if (err.code === 'ENOENT') {\n      // File doesn't exist, continue to create it\n    } else {\n      throw err; // unexpected FS error\n    }\n  }\n\n  try {\n    // Ensure the directory exists before writing the file\n    await mkdir(dirname(sentinelFilePath), { recursive: true });\n\n    // O_EXCL ensures only the *first* process can create the file\n    await writeFile(sentinelFilePath, String(currentTimestamp), { flag: 'wx' });\n  } catch (err: any) {\n    if (err.code === 'EEXIST') {\n      // Another process already created it → we're done\n      return;\n    }\n    throw err; // unexpected FS error\n  }\n\n  await callback();\n};\n"],"mappings":"AAAA,SAAS,OAAO,MAAM,QAAQ,iBAAiB;AAC/C,SAAS,eAAe;AAwBjB,MAAM,UAAU,OACrB,kBACA,UACA,YACA,iBAAyB,KAAK,QAC3B;AACH,QAAM,mBAAmB,KAAK,IAAI;AAClC,QAAM,kBAAkB;AAExB,MAAI;AAEF,UAAM,gBAAgB,MAAM,KAAK,gBAAgB;AACjD,UAAM,cAAc,mBAAmB,cAAc,MAAM,QAAQ;AAGnE,QAAI,cAAc,iBAAiB;AACjC,YAAM,OAAO,gBAAgB;AAAA,IAE/B,OAAO;AACL,YAAM,aAAa;AAEnB;AAAA,IACF;AAAA,EACF,SAAS,KAAU;AACjB,QAAI,IAAI,SAAS,UAAU;AAAA,IAE3B,OAAO;AACL,YAAM;AAAA,IACR;AAAA,EACF;AAEA,MAAI;AAEF,UAAM,MAAM,QAAQ,gBAAgB,GAAG,EAAE,WAAW,KAAK,CAAC;AAG1D,UAAM,UAAU,kBAAkB,OAAO,gBAAgB,GAAG,EAAE,MAAM,KAAK,CAAC;AAAA,EAC5E,SAAS,KAAU;AACjB,QAAI,IAAI,SAAS,UAAU;AAEzB;AAAA,IACF;AACA,UAAM;AAAA,EACR;AAEA,QAAM,SAAS;AACjB;","names":[]}

package/dist/esm/writeContentDeclaration/formatCode.mjs

@@ -1,4 +1,4 @@
-import { getAppLogger } from "@intlayer/config";
+import { ANSIColors, getAppLogger } from "@intlayer/config";
 import configuration from "@intlayer/config/built";
 import { relative } from "path";
 const formatCode = async (filePath, code) => {
@@ -17,10 +17,13 @@ const formatCode = async (filePath, code) => {
         // Explicitly provide the filepath so Prettier can infer the parser
       });
       const relativePath = relative(configuration.content.baseDir, filePath);
-      appLogger(`Applied Prettier formatting to ${relativePath}`, {
-        level: "info",
-        isVerbose: true
-      });
+      appLogger(
+        `Applied Prettier formatting to ${ANSIColors.GREY}${relativePath}${ANSIColors.RESET}`,
+        {
+          level: "info",
+          isVerbose: true
+        }
+      );
       return formattedCode;
     } catch (error) {
       const err = error;

package/dist/esm/writeContentDeclaration/formatCode.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/writeContentDeclaration/formatCode.ts"],"sourcesContent":["import { getAppLogger } from '@intlayer/config';\nimport configuration from '@intlayer/config/built';\nimport { relative } from 'path';\n\nexport const formatCode = async (filePath: string, code: string) => {\n  const appLogger = getAppLogger(configuration);\n  // Try to import prettier if it exists\n  let prettier: any;\n  try {\n    prettier = require('prettier');\n  } catch (error) {\n    // Prettier is not installed, continue without it\n  }\n\n  // Apply Prettier formatting if it's available\n  if (prettier) {\n    try {\n      // Try to find a prettier config file\n      const prettierConfig = await prettier.resolveConfig(filePath ?? '');\n\n      // Format the code with Prettier\n      const formattedCode = await prettier.format(code, {\n        ...prettierConfig,\n        filepath: filePath, // Explicitly provide the filepath so Prettier can infer the parser\n      });\n\n      const relativePath = relative(configuration.content.baseDir, filePath);\n\n      appLogger(`Applied Prettier formatting to ${relativePath}`, {\n        level: 'info',\n        isVerbose: true,\n      });\n\n      return formattedCode;\n    } catch (error) {\n      const err = error as Error;\n      appLogger(\n        `Failed to apply Prettier formatting to ${filePath}: ${err.message}`,\n        {\n          level: 'warn',\n          isVerbose: true,\n        }\n      );\n      // Continue with unformatted code on prettier error\n    }\n  }\n\n  return code;\n};\n"],"mappings":"AAAA,SAAS,oBAAoB;AAC7B,OAAO,mBAAmB;AAC1B,SAAS,gBAAgB;AAElB,MAAM,aAAa,OAAO,UAAkB,SAAiB;AAClE,QAAM,YAAY,aAAa,aAAa;AAE5C,MAAI;AACJ,MAAI;AACF,eAAW,QAAQ,UAAU;AAAA,EAC/B,SAAS,OAAO;AAAA,EAEhB;AAGA,MAAI,UAAU;AACZ,QAAI;AAEF,YAAM,iBAAiB,MAAM,SAAS,cAAc,YAAY,EAAE;AAGlE,YAAM,gBAAgB,MAAM,SAAS,OAAO,MAAM;AAAA,QAChD,GAAG;AAAA,QACH,UAAU;AAAA;AAAA,MACZ,CAAC;AAED,YAAM,eAAe,SAAS,cAAc,QAAQ,SAAS,QAAQ;AAErE,gBAAU,kCAAkC,YAAY,IAAI;AAAA,QAC1D,OAAO;AAAA,QACP,WAAW;AAAA,MACb,CAAC;AAED,aAAO;AAAA,IACT,SAAS,OAAO;AACd,YAAM,MAAM;AACZ;AAAA,QACE,0CAA0C,QAAQ,KAAK,IAAI,OAAO;AAAA,QAClE;AAAA,UACE,OAAO;AAAA,UACP,WAAW;AAAA,QACb;AAAA,MACF;AAAA,IAEF;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../../src/writeContentDeclaration/formatCode.ts"],"sourcesContent":["import { ANSIColors, getAppLogger } from '@intlayer/config';\nimport configuration from '@intlayer/config/built';\nimport { relative } from 'path';\n\nexport const formatCode = async (filePath: string, code: string) => {\n  const appLogger = getAppLogger(configuration);\n  // Try to import prettier if it exists\n  let prettier: any;\n  try {\n    prettier = require('prettier');\n  } catch (error) {\n    // Prettier is not installed, continue without it\n  }\n\n  // Apply Prettier formatting if it's available\n  if (prettier) {\n    try {\n      // Try to find a prettier config file\n      const prettierConfig = await prettier.resolveConfig(filePath ?? '');\n\n      // Format the code with Prettier\n      const formattedCode = await prettier.format(code, {\n        ...prettierConfig,\n        filepath: filePath, // Explicitly provide the filepath so Prettier can infer the parser\n      });\n\n      const relativePath = relative(configuration.content.baseDir, filePath);\n\n      appLogger(\n        `Applied Prettier formatting to ${ANSIColors.GREY}${relativePath}${ANSIColors.RESET}`,\n        {\n          level: 'info',\n          isVerbose: true,\n        }\n      );\n\n      return formattedCode;\n    } catch (error) {\n      const err = error as Error;\n      appLogger(\n        `Failed to apply Prettier formatting to ${filePath}: ${err.message}`,\n        {\n          level: 'warn',\n          isVerbose: true,\n        }\n      );\n      // Continue with unformatted code on prettier error\n    }\n  }\n\n  return code;\n};\n"],"mappings":"AAAA,SAAS,YAAY,oBAAoB;AACzC,OAAO,mBAAmB;AAC1B,SAAS,gBAAgB;AAElB,MAAM,aAAa,OAAO,UAAkB,SAAiB;AAClE,QAAM,YAAY,aAAa,aAAa;AAE5C,MAAI;AACJ,MAAI;AACF,eAAW,QAAQ,UAAU;AAAA,EAC/B,SAAS,OAAO;AAAA,EAEhB;AAGA,MAAI,UAAU;AACZ,QAAI;AAEF,YAAM,iBAAiB,MAAM,SAAS,cAAc,YAAY,EAAE;AAGlE,YAAM,gBAAgB,MAAM,SAAS,OAAO,MAAM;AAAA,QAChD,GAAG;AAAA,QACH,UAAU;AAAA;AAAA,MACZ,CAAC;AAED,YAAM,eAAe,SAAS,cAAc,QAAQ,SAAS,QAAQ;AAErE;AAAA,QACE,kCAAkC,WAAW,IAAI,GAAG,YAAY,GAAG,WAAW,KAAK;AAAA,QACnF;AAAA,UACE,OAAO;AAAA,UACP,WAAW;AAAA,QACb;AAAA,MACF;AAEA,aAAO;AAAA,IACT,SAAS,OAAO;AACd,YAAM,MAAM;AACZ;AAAA,QACE,0CAA0C,QAAQ,KAAK,IAAI,OAAO;AAAA,QAClE;AAAA,UACE,OAAO;AAAA,UACP,WAAW;AAAA,QACb;AAAA,MACF;AAAA,IAEF;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/esm/writeContentDeclaration/writeContentDeclaration.mjs

@@ -1,4 +1,5 @@
 import configuration from "@intlayer/config/built";
+import { colorizePath, x } from "@intlayer/config/client";
 import dictionariesRecord from "@intlayer/unmerged-dictionaries-entry";
 import deepEqual from "deep-equal";
 import { existsSync } from "fs";
@@ -41,7 +42,7 @@ const writeContentDeclaration = async (dictionary, config = configuration, newDi
           formattedContentDeclaration
         );
         return {
-          status: "reimported in new location",
+          status: "new content file",
           path: contentDeclarationPath
         };
       }
@@ -81,7 +82,10 @@ const writeFileWithDirectories = async (filePath, data) => {
       await writeJSFile(filePath, data);
     }
   } catch (error) {
-    throw new Error(`Error writing file to ${filePath}: ${error}`);
+    console.error(data);
+    throw new Error(
+      `${x} Error writing file to ${colorizePath(filePath)}: ${error}`
+    );
   }
 };
 export {