@intlayer/chokidar 1.2.0 → 2.0.0

package/dist/esm/transpiler/declaration_file_to_dictionary/intlayer_dictionary/processContentDeclaration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/transpiler/declaration_file_to_dictionary/intlayer_dictionary/processContentDeclaration.ts"],"sourcesContent":["import { resolve } from 'path';\nimport type {\n  Content,\n  ContentModule,\n  FlatContent,\n  FlatContentValue,\n} from '@intlayer/core';\nimport { loadContentDeclaration } from './loadContentDeclaration';\n\n/**\n * Function to replace function and async function fields with their results in the object\n */\nconst processFunctionResults = async (entry: Content): Promise<FlatContent> => {\n  if (entry && typeof entry === 'object') {\n    const promises: Promise<void>[] = [];\n    const result: FlatContent = {};\n\n    for (const key of Object.keys(entry)) {\n      const field = entry?.[key];\n\n      if (typeof field === 'object') {\n        result[key] = (await processFunctionResults(\n          field as Content\n        )) as FlatContentValue;\n      } else if (typeof field === 'function') {\n        // Wait for the function to resolve if it's an async function\n        const promise = (async () => {\n          // Execute the function and await the result if it's a Promise\n          const value = await field();\n\n          result[key] = value as FlatContentValue;\n        })();\n        promises.push(promise);\n      } else {\n        result[key] = field as FlatContentValue;\n      }\n    }\n\n    // Wait for all async operations to complete\n    await Promise.all(promises);\n\n    return result;\n  }\n\n  return entry;\n};\n\n/**\n * Function to load, process the module and return the Intlayer ContentModule from the module file\n */\nexport const processContentDeclaration = async (file: string) => {\n  try {\n    const functionPath = resolve(file);\n    const entry = loadContentDeclaration(functionPath);\n\n    if (!entry) {\n      console.error('No entry found in module:', functionPath);\n      return;\n    }\n\n    return (await processFunctionResults(entry)) as ContentModule;\n  } catch (error) {\n    console.error('Error processing module:', error);\n  }\n};\n"],"mappings":"AAAA,SAAS,eAAe;AAOxB,SAAS,8BAA8B;AAKvC,MAAM,yBAAyB,OAAO,UAAyC;AAC7E,MAAI,SAAS,OAAO,UAAU,UAAU;AACtC,UAAM,WAA4B,CAAC;AACnC,UAAM,SAAsB,CAAC;AAE7B,eAAW,OAAO,OAAO,KAAK,KAAK,GAAG;AACpC,YAAM,QAAQ,QAAQ,GAAG;AAEzB,UAAI,OAAO,UAAU,UAAU;AAC7B,eAAO,GAAG,IAAK,MAAM;AAAA,UACnB;AAAA,QACF;AAAA,MACF,WAAW,OAAO,UAAU,YAAY;AAEtC,cAAM,WAAW,YAAY;AAE3B,gBAAM,QAAQ,MAAM,MAAM;AAE1B,iBAAO,GAAG,IAAI;AAAA,QAChB,GAAG;AACH,iBAAS,KAAK,OAAO;AAAA,MACvB,OAAO;AACL,eAAO,GAAG,IAAI;AAAA,MAChB;AAAA,IACF;AAGA,UAAM,QAAQ,IAAI,QAAQ;AAE1B,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAKO,MAAM,4BAA4B,OAAO,SAAiB;AAC/D,MAAI;AACF,UAAM,eAAe,QAAQ,IAAI;AACjC,UAAM,QAAQ,uBAAuB,YAAY;AAEjD,QAAI,CAAC,OAAO;AACV,cAAQ,MAAM,6BAA6B,YAAY;AACvD;AAAA,IACF;AAEA,WAAQ,MAAM,uBAAuB,KAAK;AAAA,EAC5C,SAAS,OAAO;AACd,YAAQ,MAAM,4BAA4B,KAAK;AAAA,EACjD;AACF;","names":[]}

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

@@ -5,10 +5,10 @@ import { sync } from "glob";
 import { getFileHash, transformToCamelCase } from '../../utils.mjs';
 const { content, internationalization } = getConfiguration();
 const { typesDir, moduleAugmentationDir } = content;
-const { locales } = internationalization;
+const { locales, strictMode } = internationalization;
 const getTypeName = (id) => transformToCamelCase(`${id}Content`);
 const generateTypeIndexContent = (typeFiles) => {
-  let content2 = "/* eslint-disable */\nimport 'intlayer';\nimport { Locales } from '@intlayer/config'\n";
+  let content2 = "/* eslint-disable */\nimport { Locales } from 'intlayer'\n";
   const dictionariesRef = typeFiles.map((dictionaryPath) => ({
     relativePath: relative(moduleAugmentationDir, dictionaryPath),
     id: basename(dictionaryPath, ".d.ts"),
@@ -26,10 +26,11 @@ const generateTypeIndexContent = (typeFiles) => {
   const formatLocales = locales.map((locale) => {
     for (const key in Locales) {
       if (Locales[key] === locale) {
-        return `    ${key} = '${locale}'`;
+        return `Locales.${key}`;
       }
     }
-  }).join(",\n");
+  }).join(" | ");
+  const strictModeRecord = strictMode === "strict" ? `interface IConfigLocales<Content> extends Record<ExtractedLocales, Content> {}` : strictMode === "required_only" ? `interface IConfigLocales<Content> extends Record<ExtractedLocales, Content>, Partial<Record<ExcludedLocales, Content>> {}` : `interface IConfigLocales<Content> extends Partial<Record<Locales, Content>> {}`;
   content2 += `declare module 'intlayer' {
 `;
   content2 += `  interface IntlayerDictionaryTypesConnector {
@@ -37,14 +38,16 @@ ${formattedDictionaryMap}
   }
 
 `;
-  content2 += `  enum ConfigLocales {
-${formatLocales}
-  };
+  content2 += `  type ConfigLocales = ${formatLocales};
+`;
+  content2 += `  type ExtractedLocales = Extract<Locales, ConfigLocales>;
+`;
+  content2 += `  type ExcludedLocales = Exclude<Locales, ConfigLocales>;
 
 `;
-  content2 += `  interface IConfigLocales<Content> extends Record<ConfigLocales, Content> {}
+  content2 += `  ${strictModeRecord}
 `;
-  content2 += `};`;
+  content2 += `}`;
   return content2;
 };
 const 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 { existsSync, mkdirSync, writeFileSync } from 'fs';\nimport { basename, join, relative } from 'path';\nimport { Locales, getConfiguration } from '@intlayer/config';\nimport { sync } from 'glob';\nimport { getFileHash, transformToCamelCase } from '../../utils';\n\nconst { content, internationalization } = getConfiguration();\nconst { typesDir, moduleAugmentationDir } = content;\nconst { locales } = internationalization;\n\nexport const getTypeName = (id: string): string =>\n  transformToCamelCase(`${id}Content`);\n\n/**\n * This function generates the content of the module augmentation file\n */\nconst generateTypeIndexContent = (typeFiles: string[]): string => {\n  let content =\n    \"/* eslint-disable */\\nimport 'intlayer';\\nimport { Locales } from '@intlayer/config'\\n\";\n\n  const dictionariesRef = typeFiles.map((dictionaryPath) => ({\n    relativePath: relative(moduleAugmentationDir, dictionaryPath),\n    id: basename(dictionaryPath, '.d.ts'), // Get the base name as the dictionary id\n    hash: `_${getFileHash(dictionaryPath)}`, // Get the hash of the dictionary to avoid conflicts\n  }));\n\n  // Import all dictionaries\n  dictionariesRef.forEach((dictionary) => {\n    const typeName = getTypeName(dictionary.id);\n    content += `import type { ${typeName} as ${dictionary.hash} } from '${dictionary.relativePath}';\\n`;\n  });\n\n  content += '\\n';\n\n  // Format Dictionary Map\n  const formattedDictionaryMap: string = dictionariesRef\n    .map((dictionary) => `    \"${dictionary.id}\": ${dictionary.hash};`)\n    .join('\\n');\n\n  const formatLocales = locales\n    .map((locale) => {\n      for (const key in Locales) {\n        if (Locales[key as keyof typeof Locales] === locale) {\n          return `    ${key} = '${locale}'`;\n        }\n      }\n    })\n    .join(',\\n');\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   *   enum ConfigLocales {\n   *     ENGLISH = 'en',\n   *     FRENCH = 'fr',\n   *     SPANISH = 'es',\n   *   }\n   *\n   *   interface IConfigLocales<Content> extends Record<ConfigLocales, Content> {}\n   *\n   * }\n   * See https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation\n   */\n  content += `declare module 'intlayer' {\\n`;\n  content += `  interface IntlayerDictionaryTypesConnector {\\n${formattedDictionaryMap}\\n  }\\n\\n`;\n  content += `  enum ConfigLocales {\\n${formatLocales}\\n  };\\n\\n`;\n  content += `  interface IConfigLocales<Content> extends Record<ConfigLocales, Content> {}\\n`;\n  content += `};`;\n\n  return content;\n};\n\n/**\n * This function generates a index file merging all the types\n */\nexport const createModuleAugmentation = () => {\n  // Create main directory if it doesn't exist\n  if (!existsSync(moduleAugmentationDir)) {\n    mkdirSync(moduleAugmentationDir, { recursive: true });\n  }\n\n  const dictionaries: string[] = sync(`${typesDir}/**/*.d.ts`);\n  // Create the dictionary list file\n\n  const tsContent = generateTypeIndexContent(dictionaries);\n  writeFileSync(join(moduleAugmentationDir, 'intlayer.d.ts'), tsContent);\n};\n"],"mappings":"AAAA,SAAS,YAAY,WAAW,qBAAqB;AACrD,SAAS,UAAU,MAAM,gBAAgB;AACzC,SAAS,SAAS,wBAAwB;AAC1C,SAAS,YAAY;AACrB,SAAS,aAAa,4BAA4B;AAElD,MAAM,EAAE,SAAS,qBAAqB,IAAI,iBAAiB;AAC3D,MAAM,EAAE,UAAU,sBAAsB,IAAI;AAC5C,MAAM,EAAE,QAAQ,IAAI;AAEb,MAAM,cAAc,CAAC,OAC1B,qBAAqB,GAAG,EAAE,SAAS;AAKrC,MAAM,2BAA2B,CAAC,cAAgC;AAChE,MAAIA,WACF;AAEF,QAAM,kBAAkB,UAAU,IAAI,CAAC,oBAAoB;AAAA,IACzD,cAAc,SAAS,uBAAuB,cAAc;AAAA,IAC5D,IAAI,SAAS,gBAAgB,OAAO;AAAA;AAAA,IACpC,MAAM,IAAI,YAAY,cAAc,CAAC;AAAA;AAAA,EACvC,EAAE;AAGF,kBAAgB,QAAQ,CAAC,eAAe;AACtC,UAAM,WAAW,YAAY,WAAW,EAAE;AAC1C,IAAAA,YAAW,iBAAiB,QAAQ,OAAO,WAAW,IAAI,YAAY,WAAW,YAAY;AAAA;AAAA,EAC/F,CAAC;AAED,EAAAA,YAAW;AAGX,QAAM,yBAAiC,gBACpC,IAAI,CAAC,eAAe,QAAQ,WAAW,EAAE,MAAM,WAAW,IAAI,GAAG,EACjE,KAAK,IAAI;AAEZ,QAAM,gBAAgB,QACnB,IAAI,CAAC,WAAW;AACf,eAAW,OAAO,SAAS;AACzB,UAAI,QAAQ,GAA2B,MAAM,QAAQ;AACnD,eAAO,OAAO,GAAG,OAAO,MAAM;AAAA,MAChC;AAAA,IACF;AAAA,EACF,CAAC,EACA,KAAK,KAAK;AAwBb,EAAAA,YAAW;AAAA;AACX,EAAAA,YAAW;AAAA,EAAmD,sBAAsB;AAAA;AAAA;AAAA;AACpF,EAAAA,YAAW;AAAA,EAA2B,aAAa;AAAA;AAAA;AAAA;AACnD,EAAAA,YAAW;AAAA;AACX,EAAAA,YAAW;AAEX,SAAOA;AACT;AAKO,MAAM,2BAA2B,MAAM;AAE5C,MAAI,CAAC,WAAW,qBAAqB,GAAG;AACtC,cAAU,uBAAuB,EAAE,WAAW,KAAK,CAAC;AAAA,EACtD;AAEA,QAAM,eAAyB,KAAK,GAAG,QAAQ,YAAY;AAG3D,QAAM,YAAY,yBAAyB,YAAY;AACvD,gBAAc,KAAK,uBAAuB,eAAe,GAAG,SAAS;AACvE;","names":["content"]}
+{"version":3,"sources":["../../../../src/transpiler/dictionary_to_type/createModuleAugmentation.ts"],"sourcesContent":["import { existsSync, mkdirSync, writeFileSync } from 'fs';\nimport { basename, join, relative } from 'path';\nimport { Locales, getConfiguration } from '@intlayer/config';\nimport { sync } from 'glob';\nimport { getFileHash, transformToCamelCase } from '../../utils';\n\nconst { content, internationalization } = getConfiguration();\nconst { typesDir, moduleAugmentationDir } = content;\nconst { locales, strictMode } = internationalization;\n\nexport const getTypeName = (id: string): string =>\n  transformToCamelCase(`${id}Content`);\n\n/**\n * This function generates the content of the module augmentation file\n */\nconst generateTypeIndexContent = (typeFiles: string[]): string => {\n  let content = \"/* eslint-disable */\\nimport { Locales } from 'intlayer'\\n\";\n\n  const dictionariesRef = typeFiles.map((dictionaryPath) => ({\n    relativePath: relative(moduleAugmentationDir, dictionaryPath),\n    id: basename(dictionaryPath, '.d.ts'), // Get the base name as the dictionary id\n    hash: `_${getFileHash(dictionaryPath)}`, // Get the hash of the dictionary to avoid conflicts\n  }));\n\n  // Import all dictionaries\n  dictionariesRef.forEach((dictionary) => {\n    const typeName = getTypeName(dictionary.id);\n    content += `import type { ${typeName} as ${dictionary.hash} } from '${dictionary.relativePath}';\\n`;\n  });\n\n  content += '\\n';\n\n  // Format Dictionary Map\n  const formattedDictionaryMap: string = dictionariesRef\n    .map((dictionary) => `    \"${dictionary.id}\": ${dictionary.hash};`)\n    .join('\\n');\n\n  const formatLocales = 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  const strictModeRecord =\n    strictMode === 'strict'\n      ? `interface IConfigLocales<Content> extends Record<ExtractedLocales, Content> {}`\n      : strictMode === 'required_only'\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   *   type ExcludedLocales = Exclude<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  content += `declare module 'intlayer' {\\n`;\n  content += `  interface IntlayerDictionaryTypesConnector {\\n${formattedDictionaryMap}\\n  }\\n\\n`;\n  content += `  type ConfigLocales = ${formatLocales};\\n`;\n  content += `  type ExtractedLocales = Extract<Locales, ConfigLocales>;\\n`;\n  content += `  type ExcludedLocales = Exclude<Locales, ConfigLocales>;\\n\\n`;\n  content += `  ${strictModeRecord}\\n`;\n  content += `}`;\n\n  return content;\n};\n\n/**\n * This function generates a index file merging all the types\n */\nexport const createModuleAugmentation = () => {\n  // Create main directory if it doesn't exist\n  if (!existsSync(moduleAugmentationDir)) {\n    mkdirSync(moduleAugmentationDir, { recursive: true });\n  }\n\n  const dictionaries: string[] = sync(`${typesDir}/**/*.d.ts`);\n  // Create the dictionary list file\n\n  const tsContent = generateTypeIndexContent(dictionaries);\n  writeFileSync(join(moduleAugmentationDir, 'intlayer.d.ts'), tsContent);\n};\n"],"mappings":"AAAA,SAAS,YAAY,WAAW,qBAAqB;AACrD,SAAS,UAAU,MAAM,gBAAgB;AACzC,SAAS,SAAS,wBAAwB;AAC1C,SAAS,YAAY;AACrB,SAAS,aAAa,4BAA4B;AAElD,MAAM,EAAE,SAAS,qBAAqB,IAAI,iBAAiB;AAC3D,MAAM,EAAE,UAAU,sBAAsB,IAAI;AAC5C,MAAM,EAAE,SAAS,WAAW,IAAI;AAEzB,MAAM,cAAc,CAAC,OAC1B,qBAAqB,GAAG,EAAE,SAAS;AAKrC,MAAM,2BAA2B,CAAC,cAAgC;AAChE,MAAIA,WAAU;AAEd,QAAM,kBAAkB,UAAU,IAAI,CAAC,oBAAoB;AAAA,IACzD,cAAc,SAAS,uBAAuB,cAAc;AAAA,IAC5D,IAAI,SAAS,gBAAgB,OAAO;AAAA;AAAA,IACpC,MAAM,IAAI,YAAY,cAAc,CAAC;AAAA;AAAA,EACvC,EAAE;AAGF,kBAAgB,QAAQ,CAAC,eAAe;AACtC,UAAM,WAAW,YAAY,WAAW,EAAE;AAC1C,IAAAA,YAAW,iBAAiB,QAAQ,OAAO,WAAW,IAAI,YAAY,WAAW,YAAY;AAAA;AAAA,EAC/F,CAAC;AAED,EAAAA,YAAW;AAGX,QAAM,yBAAiC,gBACpC,IAAI,CAAC,eAAe,QAAQ,WAAW,EAAE,MAAM,WAAW,IAAI,GAAG,EACjE,KAAK,IAAI;AAEZ,QAAM,gBAAgB,QACnB,IAAI,CAAC,WAAW;AACf,eAAW,OAAO,SAAS;AACzB,UAAI,QAAQ,GAA2B,MAAM,QAAQ;AACnD,eAAO,WAAW,GAAG;AAAA,MACvB;AAAA,IACF;AAAA,EACF,CAAC,EACA,KAAK,KAAK;AAEb,QAAM,mBACJ,eAAe,WACX,mFACA,eAAe,kBACb,8HACA;AAuBR,EAAAA,YAAW;AAAA;AACX,EAAAA,YAAW;AAAA,EAAmD,sBAAsB;AAAA;AAAA;AAAA;AACpF,EAAAA,YAAW,0BAA0B,aAAa;AAAA;AAClD,EAAAA,YAAW;AAAA;AACX,EAAAA,YAAW;AAAA;AAAA;AACX,EAAAA,YAAW,KAAK,gBAAgB;AAAA;AAChC,EAAAA,YAAW;AAEX,SAAOA;AACT;AAKO,MAAM,2BAA2B,MAAM;AAE5C,MAAI,CAAC,WAAW,qBAAqB,GAAG;AACtC,cAAU,uBAAuB,EAAE,WAAW,KAAK,CAAC;AAAA,EACtD;AAEA,QAAM,eAAyB,KAAK,GAAG,QAAQ,YAAY;AAG3D,QAAM,YAAY,yBAAyB,YAAY;AACvD,gBAAc,KAAK,uBAAuB,eAAe,GAAG,SAAS;AACvE;","names":["content"]}

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

@@ -19,38 +19,50 @@ const generateTypeScriptType = (obj) => {
   typeDefinition += "};\n\n";
   return typeDefinition;
 };
+const isReactNode = (node) => typeof node?.key !== "undefined" && typeof node?.props !== "undefined";
 const generateTypeScriptTypeContent = (obj) => {
+  if (typeof obj !== "object" || obj === null) {
+    return `${typeof obj}`;
+  }
+  const isReactNodeValue = isReactNode(obj);
+  if (isReactNodeValue) {
+    return `JSX.Element`;
+  }
   let typeDefinition = ``;
   for (const [key, value] of Object.entries(obj)) {
-    const nodeType = value.nodeType;
+    const nodeType = value?.nodeType;
     if (
       // Check if the value is a typed node
       typeof value === "object" && nodeType === NodeType.Translation
     ) {
-      const tsType = typeof value?.[internationalization.defaultLocale];
+      const tsType = generateTypeScriptTypeContent(
+        value?.[internationalization.defaultLocale]
+      );
       typeDefinition += `  ${key}: ${tsType},
 `;
     } else if (
       // Check if the value is a typed node
       typeof value === "object" && nodeType === NodeType.Enumeration
     ) {
-      const tsType = typeof value?.[internationalization.defaultLocale];
+      const tsType = generateTypeScriptTypeContent(
+        value?.[internationalization.defaultLocale]
+      );
       typeDefinition += `  ${key}: (quantity: number) => ${tsType},
 `;
     } else if (
       // Check if the value is a nested object
-      typeof value === "object" && !Array.isArray(value)
+      typeof value === "object"
     ) {
-      const nestedType = generateTypeScriptTypeContent(value);
-      typeDefinition += `  ${key}: {${nestedType}},
+      const isArray = Array.isArray(value);
+      if (isArray) {
+        const arrayType = generateTypeScriptTypeContent(value);
+        typeDefinition += `  ${key}: ${arrayType}[],
 `;
-    } else if (
-      // Check if the value is an array
-      Array.isArray(value)
-    ) {
-      const arrayType = typeof value[0];
-      typeDefinition += `  ${key}: ${arrayType}[],
+      } else {
+        const nestedType = generateTypeScriptTypeContent(value);
+        typeDefinition += `  ${key}: {${nestedType}},
 `;
+      }
     } else if (
       // Check if the value is an 'id'
       typeof value === "string" && key === "id"

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/transpiler/dictionary_to_type/createType.ts"],"sourcesContent":["import { existsSync, mkdirSync, writeFileSync } from 'fs';\nimport { createRequire } from 'module';\nimport { resolve } from 'path';\nimport { getConfiguration } from '@intlayer/config';\nimport {\n  NodeType,\n  type Content,\n  type ContentModule,\n  type TypedNode,\n} from '@intlayer/core';\nimport { getTypeName } from './createModuleAugmentation';\n\nconst { content, internationalization } = getConfiguration();\nconst { typesDir } = content;\n\nconst isESModule = typeof import.meta.url === 'string';\nconst requireFunction = isESModule ? createRequire(import.meta.url) : require;\n\n/**\n *\n * This function generates a TypeScript type definition from a JSON object\n *\n * Example:\n *\n * const input = {\n *  id: '1',\n *  name: 'John Doe',\n *  address: {\n *      id: '2',\n *      street: '123 Main St',\n *      city: 'Springfield',\n *  }\n * };\n *\n * const result = generateTypeScriptType(input, 'RootObject');\n * console.log(result);\n *\n * Output:\n *\n * type RootObject = {\n *  id: '1',\n *  name: string,\n *  address: {\n *      id: '2',\n *      street: string,\n *      city: string,\n *  },\n * };\n *\n */\nexport const generateTypeScriptType = (obj: ContentModule): string => {\n  let typeDefinition = ``;\n\n  const typeName = getTypeName(obj.id);\n\n  typeDefinition += `export type ${typeName} = {\\n`;\n  typeDefinition += generateTypeScriptTypeContent(obj);\n  typeDefinition += '};\\n\\n';\n\n  return typeDefinition;\n};\n\nexport const generateTypeScriptTypeContent = (obj: Content): string => {\n  let typeDefinition = ``;\n\n  for (const [key, value] of Object.entries(obj)) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const nodeType: NodeType | undefined = (value as TypedNode).nodeType;\n    type ValueKey = keyof typeof value;\n\n    if (\n      // Check if the value is a typed node\n      typeof value === 'object' &&\n      nodeType === NodeType.Translation\n    ) {\n      const tsType =\n        typeof value?.[internationalization.defaultLocale as ValueKey];\n      typeDefinition += `  ${key}: ${tsType},\\n`;\n    } else if (\n      // Check if the value is a typed node\n      typeof value === 'object' &&\n      nodeType === NodeType.Enumeration\n    ) {\n      const tsType =\n        typeof value?.[internationalization.defaultLocale as ValueKey];\n\n      typeDefinition += `  ${key}: (quantity: number) => ${tsType},\\n`;\n    } else if (\n      // Check if the value is a nested object\n      typeof value === 'object' &&\n      !Array.isArray(value)\n    ) {\n      // Nested object, recurse\n      const nestedType = generateTypeScriptTypeContent(value as Content);\n      typeDefinition += `  ${key}: {${nestedType}},\\n`;\n    } else if (\n      // Check if the value is an array\n      Array.isArray(value)\n    ) {\n      // Array handling (simplified, assumes non-empty arrays with uniform type)\n      const arrayType = typeof value[0];\n      typeDefinition += `  ${key}: ${arrayType}[],\\n`;\n    } else if (\n      // Check if the value is an 'id'\n      typeof value === 'string' &&\n      key === 'id'\n    ) {\n      // Special handling for 'id' field\n      const tsType = `\"${value}\"`;\n      typeDefinition += `  ${key}: ${tsType},\\n`;\n    } else {\n      // Primitive type\n      const tsType = typeof value;\n      typeDefinition += `  ${key}: ${tsType},\\n`;\n    }\n  }\n\n  return typeDefinition;\n};\n\n/**\n * This function generates a TypeScript type definition from a JSON object\n */\nexport const createTypes = (dictionariesPaths: string[]): string[] => {\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 contentModule: ContentModule = requireFunction(dictionaryPath);\n    const dictionaryName: string = contentModule.id;\n    const typeDefinition: string = generateTypeScriptType(contentModule);\n\n    const outputPath = resolve(typesDir, `${dictionaryName}.d.ts`);\n\n    writeFileSync(outputPath, typeDefinition);\n\n    resultTypesPaths.push(outputPath);\n  }\n\n  return resultTypesPaths;\n};\n"],"mappings":"AAAA,SAAS,YAAY,WAAW,qBAAqB;AACrD,SAAS,qBAAqB;AAC9B,SAAS,eAAe;AACxB,SAAS,wBAAwB;AACjC;AAAA,EACE;AAAA,OAIK;AACP,SAAS,mBAAmB;AAE5B,MAAM,EAAE,SAAS,qBAAqB,IAAI,iBAAiB;AAC3D,MAAM,EAAE,SAAS,IAAI;AAErB,MAAM,aAAa,OAAO,YAAY,QAAQ;AAC9C,MAAM,kBAAkB,aAAa,cAAc,YAAY,GAAG,IAAI;AAkC/D,MAAM,yBAAyB,CAAC,QAA+B;AACpE,MAAI,iBAAiB;AAErB,QAAM,WAAW,YAAY,IAAI,EAAE;AAEnC,oBAAkB,eAAe,QAAQ;AAAA;AACzC,oBAAkB,8BAA8B,GAAG;AACnD,oBAAkB;AAElB,SAAO;AACT;AAEO,MAAM,gCAAgC,CAAC,QAAyB;AACrE,MAAI,iBAAiB;AAErB,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,GAAG,GAAG;AAE9C,UAAM,WAAkC,MAAoB;AAG5D;AAAA;AAAA,MAEE,OAAO,UAAU,YACjB,aAAa,SAAS;AAAA,MACtB;AACA,YAAM,SACJ,OAAO,QAAQ,qBAAqB,aAAyB;AAC/D,wBAAkB,KAAK,GAAG,KAAK,MAAM;AAAA;AAAA,IACvC;AAAA;AAAA,MAEE,OAAO,UAAU,YACjB,aAAa,SAAS;AAAA,MACtB;AACA,YAAM,SACJ,OAAO,QAAQ,qBAAqB,aAAyB;AAE/D,wBAAkB,KAAK,GAAG,2BAA2B,MAAM;AAAA;AAAA,IAC7D;AAAA;AAAA,MAEE,OAAO,UAAU,YACjB,CAAC,MAAM,QAAQ,KAAK;AAAA,MACpB;AAEA,YAAM,aAAa,8BAA8B,KAAgB;AACjE,wBAAkB,KAAK,GAAG,MAAM,UAAU;AAAA;AAAA,IAC5C;AAAA;AAAA,MAEE,MAAM,QAAQ,KAAK;AAAA,MACnB;AAEA,YAAM,YAAY,OAAO,MAAM,CAAC;AAChC,wBAAkB,KAAK,GAAG,KAAK,SAAS;AAAA;AAAA,IAC1C;AAAA;AAAA,MAEE,OAAO,UAAU,YACjB,QAAQ;AAAA,MACR;AAEA,YAAM,SAAS,IAAI,KAAK;AACxB,wBAAkB,KAAK,GAAG,KAAK,MAAM;AAAA;AAAA,IACvC,OAAO;AAEL,YAAM,SAAS,OAAO;AACtB,wBAAkB,KAAK,GAAG,KAAK,MAAM;AAAA;AAAA,IACvC;AAAA,EACF;AAEA,SAAO;AACT;AAKO,MAAM,cAAc,CAAC,sBAA0C;AACpE,QAAM,mBAA6B,CAAC;AAGpC,MAAI,CAAC,WAAW,QAAQ,GAAG;AACzB,cAAU,UAAU,EAAE,WAAW,KAAK,CAAC;AAAA,EACzC;AAEA,aAAW,kBAAkB,mBAAmB;AAC9C,UAAM,gBAA+B,gBAAgB,cAAc;AACnE,UAAM,iBAAyB,cAAc;AAC7C,UAAM,iBAAyB,uBAAuB,aAAa;AAEnE,UAAM,aAAa,QAAQ,UAAU,GAAG,cAAc,OAAO;AAE7D,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 { existsSync, mkdirSync, writeFileSync } from 'fs';\nimport { createRequire } from 'module';\nimport { resolve } from 'path';\nimport { getConfiguration } from '@intlayer/config';\nimport {\n  NodeType,\n  type Content,\n  type ContentModule,\n  type TypedNode,\n} from '@intlayer/core';\nimport { getTypeName } from './createModuleAugmentation';\n\nconst { content, internationalization } = getConfiguration();\nconst { typesDir } = content;\n\nconst isESModule = typeof import.meta.url === 'string';\nconst requireFunction = isESModule ? createRequire(import.meta.url) : require;\n\n/**\n *\n * This function generates a TypeScript type definition from a JSON object\n *\n * Example:\n *\n * const input = {\n *  id: '1',\n *  name: 'John Doe',\n *  address: {\n *      id: '2',\n *      street: '123 Main St',\n *      city: 'Springfield',\n *  }\n * };\n *\n * const result = generateTypeScriptType(input, 'RootObject');\n * console.log(result);\n *\n * Output:\n *\n * type RootObject = {\n *  id: '1',\n *  name: string,\n *  address: {\n *      id: '2',\n *      street: string,\n *      city: string,\n *  },\n * };\n *\n */\nexport const generateTypeScriptType = (obj: ContentModule): string => {\n  let typeDefinition = ``;\n\n  const typeName = getTypeName(obj.id);\n\n  typeDefinition += `export type ${typeName} = {\\n`;\n  typeDefinition += generateTypeScriptTypeContent(obj);\n  typeDefinition += '};\\n\\n';\n\n  return typeDefinition;\n};\n\nconst isReactNode = (node: Record<string, unknown>): boolean =>\n  typeof node?.key !== 'undefined' && typeof node?.props !== 'undefined';\n\n// eslint-disable-next-line sonarjs/cognitive-complexity\nexport const generateTypeScriptTypeContent = (obj: Content): string => {\n  if (typeof obj !== 'object' || obj === null) {\n    return `${typeof obj}`;\n  }\n\n  const isReactNodeValue = isReactNode(obj as Record<string, unknown>);\n\n  if (isReactNodeValue) {\n    // ReactNode handling\n    return `JSX.Element`;\n  }\n\n  let typeDefinition = ``;\n  for (const [key, value] of Object.entries(obj)) {\n    const nodeType: NodeType | undefined = (value as TypedNode)?.nodeType;\n    type ValueKey = keyof typeof value;\n\n    if (\n      // Check if the value is a typed node\n      typeof value === 'object' &&\n      nodeType === NodeType.Translation\n    ) {\n      const tsType = generateTypeScriptTypeContent(\n        value?.[internationalization.defaultLocale as ValueKey]\n      );\n      typeDefinition += `  ${key}: ${tsType},\\n`;\n    } else if (\n      // Check if the value is a typed node\n      typeof value === 'object' &&\n      nodeType === NodeType.Enumeration\n    ) {\n      const tsType = generateTypeScriptTypeContent(\n        value?.[internationalization.defaultLocale as ValueKey] as Content\n      );\n\n      typeDefinition += `  ${key}: (quantity: number) => ${tsType},\\n`;\n    } else if (\n      // Check if the value is a nested object\n      typeof value === 'object'\n    ) {\n      const isArray = Array.isArray(value);\n\n      if (isArray) {\n        // Array handling (simplified, assumes non-empty arrays with uniform type)\n        const arrayType = generateTypeScriptTypeContent(value as Content);\n\n        typeDefinition += `  ${key}: ${arrayType}[],\\n`;\n      } else {\n        // Nested object, recurse\n        const nestedType = generateTypeScriptTypeContent(value as Content);\n\n        typeDefinition += `  ${key}: {${nestedType}},\\n`;\n      }\n    } else if (\n      // Check if the value is an 'id'\n      typeof value === 'string' &&\n      key === 'id'\n    ) {\n      // Special handling for 'id' field\n      const tsType = `\"${value}\"`;\n      typeDefinition += `  ${key}: ${tsType},\\n`;\n    } else {\n      // Primitive type\n      const tsType = typeof value;\n      typeDefinition += `  ${key}: ${tsType},\\n`;\n    }\n  }\n\n  return typeDefinition;\n};\n\n/**\n * This function generates a TypeScript type definition from a JSON object\n */\nexport const createTypes = (dictionariesPaths: string[]): string[] => {\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 contentModule: ContentModule = requireFunction(dictionaryPath);\n    const dictionaryName: string = contentModule.id;\n    const typeDefinition: string = generateTypeScriptType(contentModule);\n\n    const outputPath = resolve(typesDir, `${dictionaryName}.d.ts`);\n\n    writeFileSync(outputPath, typeDefinition);\n\n    resultTypesPaths.push(outputPath);\n  }\n\n  return resultTypesPaths;\n};\n"],"mappings":"AAAA,SAAS,YAAY,WAAW,qBAAqB;AACrD,SAAS,qBAAqB;AAC9B,SAAS,eAAe;AACxB,SAAS,wBAAwB;AACjC;AAAA,EACE;AAAA,OAIK;AACP,SAAS,mBAAmB;AAE5B,MAAM,EAAE,SAAS,qBAAqB,IAAI,iBAAiB;AAC3D,MAAM,EAAE,SAAS,IAAI;AAErB,MAAM,aAAa,OAAO,YAAY,QAAQ;AAC9C,MAAM,kBAAkB,aAAa,cAAc,YAAY,GAAG,IAAI;AAkC/D,MAAM,yBAAyB,CAAC,QAA+B;AACpE,MAAI,iBAAiB;AAErB,QAAM,WAAW,YAAY,IAAI,EAAE;AAEnC,oBAAkB,eAAe,QAAQ;AAAA;AACzC,oBAAkB,8BAA8B,GAAG;AACnD,oBAAkB;AAElB,SAAO;AACT;AAEA,MAAM,cAAc,CAAC,SACnB,OAAO,MAAM,QAAQ,eAAe,OAAO,MAAM,UAAU;AAGtD,MAAM,gCAAgC,CAAC,QAAyB;AACrE,MAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AAC3C,WAAO,GAAG,OAAO,GAAG;AAAA,EACtB;AAEA,QAAM,mBAAmB,YAAY,GAA8B;AAEnE,MAAI,kBAAkB;AAEpB,WAAO;AAAA,EACT;AAEA,MAAI,iBAAiB;AACrB,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,GAAG,GAAG;AAC9C,UAAM,WAAkC,OAAqB;AAG7D;AAAA;AAAA,MAEE,OAAO,UAAU,YACjB,aAAa,SAAS;AAAA,MACtB;AACA,YAAM,SAAS;AAAA,QACb,QAAQ,qBAAqB,aAAyB;AAAA,MACxD;AACA,wBAAkB,KAAK,GAAG,KAAK,MAAM;AAAA;AAAA,IACvC;AAAA;AAAA,MAEE,OAAO,UAAU,YACjB,aAAa,SAAS;AAAA,MACtB;AACA,YAAM,SAAS;AAAA,QACb,QAAQ,qBAAqB,aAAyB;AAAA,MACxD;AAEA,wBAAkB,KAAK,GAAG,2BAA2B,MAAM;AAAA;AAAA,IAC7D;AAAA;AAAA,MAEE,OAAO,UAAU;AAAA,MACjB;AACA,YAAM,UAAU,MAAM,QAAQ,KAAK;AAEnC,UAAI,SAAS;AAEX,cAAM,YAAY,8BAA8B,KAAgB;AAEhE,0BAAkB,KAAK,GAAG,KAAK,SAAS;AAAA;AAAA,MAC1C,OAAO;AAEL,cAAM,aAAa,8BAA8B,KAAgB;AAEjE,0BAAkB,KAAK,GAAG,MAAM,UAAU;AAAA;AAAA,MAC5C;AAAA,IACF;AAAA;AAAA,MAEE,OAAO,UAAU,YACjB,QAAQ;AAAA,MACR;AAEA,YAAM,SAAS,IAAI,KAAK;AACxB,wBAAkB,KAAK,GAAG,KAAK,MAAM;AAAA;AAAA,IACvC,OAAO;AAEL,YAAM,SAAS,OAAO;AACtB,wBAAkB,KAAK,GAAG,KAAK,MAAM;AAAA;AAAA,IACvC;AAAA,EACF;AAEA,SAAO;AACT;AAKO,MAAM,cAAc,CAAC,sBAA0C;AACpE,QAAM,mBAA6B,CAAC;AAGpC,MAAI,CAAC,WAAW,QAAQ,GAAG;AACzB,cAAU,UAAU,EAAE,WAAW,KAAK,CAAC;AAAA,EACzC;AAEA,aAAW,kBAAkB,mBAAmB;AAC9C,UAAM,gBAA+B,gBAAgB,cAAc;AACnE,UAAM,iBAAyB,cAAc;AAC7C,UAAM,iBAAyB,uBAAuB,aAAa;AAEnE,UAAM,aAAa,QAAQ,UAAU,GAAG,cAAc,OAAO;AAE7D,kBAAc,YAAY,cAAc;AAExC,qBAAiB,KAAK,UAAU;AAAA,EAClC;AAEA,SAAO;AACT;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/chokidar",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "private": false,
   "description": "Chokidar application for IntLayer - Transpile IntLayer declaration files into dictionaries.",
   "keywords": [
@@ -53,9 +53,9 @@
     "glob": "^10.3.12",
     "node-loader": "^2.0.0",
     "rimraf": "5.0.5",
-    "@intlayer/config": "^1.2.0",
-    "@intlayer/core": "^1.2.0",
-    "intlayer": "^1.2.0"
+    "@intlayer/config": "^2.0.0",
+    "@intlayer/core": "^2.0.0",
+    "intlayer": "^2.0.0"
   },
   "devDependencies": {
     "@changesets/cli": "2.27.1",

package/src/chokidar/watcher.ts

@@ -2,18 +2,19 @@ import { relative } from 'path';
 import { getConfiguration } from '@intlayer/config';
 import chokidar, { type WatchOptions } from 'chokidar';
 import { sync } from 'glob';
+import { buildDictionary } from '../transpiler/declaration_file_to_dictionary/index';
 import { createDictionaryList } from '../transpiler/dictionary_to_main/createDictionaryList';
 import {
   createTypes,
   createModuleAugmentation,
 } from '../transpiler/dictionary_to_type/index';
-import { transpileContentDeclaration } from '../transpiler/intlater_module_to_dictionary/transpileContentDeclaration';
 
 // Initialize chokidar watcher (non-persistent)
 export const watch = (options?: WatchOptions) => {
   const { content } = getConfiguration({
     verbose: true,
   });
+
   const { watchedFilesPatternWithPath, baseDir } = content;
 
   const files: string[] = sync(watchedFilesPatternWithPath);
@@ -25,7 +26,7 @@ export const watch = (options?: WatchOptions) => {
       ...options,
     })
     .on('ready', async () => {
-      const dictionariesPaths = await transpileContentDeclaration(files);
+      const dictionariesPaths = await buildDictionary(files);
 
       console.info('Building Intlayer types...');
       createTypes(dictionariesPaths);
@@ -45,21 +46,11 @@ export const watch = (options?: WatchOptions) => {
     .on('unlink', (filePath) => {
       // Process the file with the functionToRun
       console.info('Removed file detected: ', relative(baseDir, filePath));
-      // await transpileContentDeclaration(filePath);
-
-      // console.info('Building TypeScript types...');
-      // createTypes([filePath]);
-
-      // console.info('Building type index...');
-      // createModuleAugmentation();
-
-      // console.info('Building main...');
-      // createDictionaryList();
     })
     .on('add', async (filePath) => {
       // Process the file with the functionToRun
       console.info('Additional file detected: ', relative(baseDir, filePath));
-      const dictionaries = await transpileContentDeclaration(filePath);
+      const dictionaries = await buildDictionary(filePath);
 
       console.info('Building TypeScript types...');
       createTypes(dictionaries);
@@ -73,7 +64,7 @@ export const watch = (options?: WatchOptions) => {
     .on('change', async (filePath) => {
       // Process the file with the functionToRun
       console.info('Change detected: ', relative(baseDir, filePath));
-      const dictionaries = await transpileContentDeclaration(filePath);
+      const dictionaries = await buildDictionary(filePath);
 
       console.info('Building TypeScript types...');
       createTypes(dictionaries);

package/src/transpiler/declaration_file_to_dictionary/i18n_dictionary/buildI18nDictionary.ts

@@ -0,0 +1,95 @@
+import { mkdir, writeFile } from 'fs/promises';
+import { resolve } from 'path';
+import { getConfiguration } from '@intlayer/config';
+import type { ContentModule } from '@intlayer/core';
+import {
+  processContentDeclaration,
+  extractObjectsWithId,
+} from '../intlayer_dictionary/index';
+import {
+  type I18nDictionariesOutput,
+  createI18nDictionaries,
+} from './convertContentDeclarationInto18nDictionaries';
+
+const { content } = getConfiguration();
+const { i18nDictionariesDir } = content;
+
+type DictionariesDeclaration = Record<string, I18nDictionariesOutput>;
+
+/**
+ * This function writes the dictionaries to the file system
+ */
+const writeDictionary = async (
+  dictionariesDeclaration: DictionariesDeclaration
+) => {
+  const resultDictionariesPaths: string[] = [];
+
+  for (const [nameSpace, localContent] of Object.entries(
+    dictionariesDeclaration
+  )) {
+    for await (const [locale, content] of Object.entries(localContent)) {
+      const contentString = JSON.stringify(content);
+
+      const outputFileName = `${nameSpace}.json`;
+      const resultDirPath = resolve(i18nDictionariesDir, locale);
+      const resultFilePath = resolve(resultDirPath, outputFileName);
+
+      // Create the dictionaries folder if it doesn't exist
+      await mkdir(resultDirPath, { recursive: true });
+
+      // Create the json file
+      await writeFile(resultFilePath, contentString, 'utf8').catch((err) => {
+        console.error(`Error creating ${outputFileName}:`, err);
+      });
+
+      resultDictionariesPaths.push(resultFilePath);
+    }
+  }
+
+  return resultDictionariesPaths;
+};
+
+/**
+ * This function transpile content declaration to i18n dictionaries
+ */
+export const buildI18nDictionary = async (
+  contentDeclarationsPaths: string[] | string
+) => {
+  const resultDictionariesPaths: string[] = [];
+
+  if (typeof contentDeclarationsPaths === 'string') {
+    contentDeclarationsPaths = [contentDeclarationsPaths];
+  }
+
+  for await (const contentDeclarationPath of contentDeclarationsPaths) {
+    const result = await processContentDeclaration(contentDeclarationPath);
+
+    if (!result) {
+      continue;
+    }
+
+    const nestedContent: ContentModule[] = extractObjectsWithId(result);
+
+    // Create dictionaries for each nested content and format them
+    const dictionariesDeclaration: DictionariesDeclaration =
+      nestedContent.reduce((acc, content) => {
+        const id = content.id;
+        const i18Content = createI18nDictionaries(content);
+
+        return {
+          ...acc,
+          [id]: i18Content,
+        };
+      }, {});
+
+    // Write the dictionaries to the file system
+    const dictionariesPaths: string[] = await writeDictionary(
+      dictionariesDeclaration
+    );
+
+    // Add the paths to the result
+    resultDictionariesPaths.push(...dictionariesPaths);
+  }
+
+  return resultDictionariesPaths;
+};

package/src/transpiler/declaration_file_to_dictionary/i18n_dictionary/convertContentDeclarationInto18nDictionaries.ts

@@ -0,0 +1,91 @@
+import { getConfiguration, type Locales } from '@intlayer/config';
+import {
+  NodeType,
+  type TranslationContent,
+  type Content,
+  type TypedNode,
+  type EnumerationContent,
+} from '@intlayer/core';
+import { convertPluralsValues } from './convertPluralsValues';
+
+type Dictionary = Record<string, unknown>;
+export type I18nDictionariesOutput = Partial<Record<Locales, Dictionary>>;
+
+const {
+  internationalization: { locales },
+} = getConfiguration();
+
+const isReactNode = (node: Record<string, unknown>): boolean =>
+  typeof node?.key !== 'undefined' &&
+  typeof node?.props !== 'undefined' &&
+  typeof node?.type !== 'undefined';
+
+// Build dictionary for a specific locale
+const buildDictionary = (content: Dictionary, locale: Locales): unknown => {
+  if (
+    // Translation node
+    content &&
+    (content as TypedNode).nodeType === NodeType.Translation
+  ) {
+    const result = (content as TranslationContent<unknown>)[locale];
+
+    return buildDictionary(result as Dictionary, locale);
+  } else if (
+    // Translation node
+    content &&
+    (content as TypedNode).nodeType === NodeType.Enumeration
+  ) {
+    const plurals: Record<string, unknown> = {};
+
+    Object.keys(content).forEach((quantity) => {
+      const letterNumber = convertPluralsValues(quantity);
+
+      const value = (content as EnumerationContent<unknown>)[
+        quantity as keyof EnumerationContent<unknown>
+      ];
+
+      plurals[`${letterNumber}_${letterNumber}`] = buildDictionary(
+        value as Dictionary,
+        locale
+      );
+    });
+
+    return plurals;
+  } else if (
+    // React element node
+    isReactNode(content as Record<string, unknown>)
+  ) {
+    return JSON.stringify(content);
+  } else if (
+    // Nested object
+    typeof content === 'object'
+  ) {
+    const result: Record<string, unknown> = {};
+
+    Object.keys(content).forEach((dictionaryValue) => {
+      result[dictionaryValue] = buildDictionary(
+        content[dictionaryValue] as Dictionary,
+        locale
+      );
+    });
+
+    return result;
+  }
+
+  return content;
+};
+
+export const createI18nDictionaries = (
+  content: Content
+): I18nDictionariesOutput => {
+  // Map dictionaries for each locale
+  const result: I18nDictionariesOutput = locales.reduce(
+    (acc, locale) => ({
+      ...acc,
+      [locale]: buildDictionary(content, locale),
+    }),
+    {}
+  );
+
+  return result;
+};

package/src/transpiler/declaration_file_to_dictionary/i18n_dictionary/convertPluralsValues.ts

@@ -0,0 +1,22 @@
+export const convertPluralsValues = (number: string): string => {
+  switch (number) {
+    case '1':
+      return 'one';
+    case '2':
+      return 'two';
+    case '3':
+      return 'three';
+    case '4':
+      return 'four';
+    case '5':
+      return 'five';
+    case '6':
+      return 'six';
+    case '7':
+      return 'seven';
+    case '8':
+      return 'eight';
+    default:
+      return number.toString();
+  }
+};

package/src/transpiler/declaration_file_to_dictionary/i18n_dictionary/index.ts

@@ -0,0 +1 @@
+export * from './buildI18nDictionary';

package/src/transpiler/declaration_file_to_dictionary/index.ts

@@ -0,0 +1,21 @@
+import { getConfiguration } from '@intlayer/config';
+import { buildI18nDictionary } from './i18n_dictionary/index';
+import { buildIntlayerDictionary } from './intlayer_dictionary/index';
+
+const {
+  content: { dictionaryOutput },
+} = getConfiguration();
+
+export const buildDictionary = async (
+  contentDeclarationsPaths: string | string[]
+): Promise<string[]> => {
+  if (dictionaryOutput.includes('i18next')) {
+    return await buildI18nDictionary(contentDeclarationsPaths);
+  }
+
+  if (dictionaryOutput.includes('intlayer')) {
+    return await buildIntlayerDictionary(contentDeclarationsPaths);
+  }
+
+  return [];
+};

package/src/transpiler/{intlater_module_to_dictionary/transpileContentDeclaration.ts → declaration_file_to_dictionary/intlayer_dictionary/buildIntlayerDictionary.ts}

@@ -3,12 +3,12 @@ import { resolve } from 'path';
 import { getConfiguration } from '@intlayer/config';
 import type { ContentModule } from '@intlayer/core';
 import { extractObjectsWithId } from './extractNestedJSON';
-import { processContentDeclaration } from './processModule';
+import { processContentDeclaration } from './processContentDeclaration';
 
 const { content } = getConfiguration();
 const { dictionariesDir } = content;
 
-const buildDictionary = async (dictionaries: ContentModule[]) => {
+const writeDictionary = async (dictionaries: ContentModule[]) => {
   const resultDictionariesPaths: string[] = [];
 
   for await (const content of dictionaries) {
@@ -32,7 +32,7 @@ const buildDictionary = async (dictionaries: ContentModule[]) => {
 /**
  * This function transpile the bundled code to to make dictionaries as JSON files
  */
-export const transpileContentDeclaration = async (
+export const buildIntlayerDictionary = async (
   contentDeclarationsPaths: string[] | string
 ) => {
   const resultDictionariesPaths: string[] = [];
@@ -53,7 +53,15 @@ export const transpileContentDeclaration = async (
 
     const nestedContent: ContentModule[] = extractObjectsWithId(result);
 
-    const dictionariesPaths: string[] = await buildDictionary(nestedContent);
+    const contentWithFilePath: ContentModule[] = nestedContent.map(
+      (content) => ({
+        ...content,
+        filePath: contentDeclarationPath,
+      })
+    );
+
+    const dictionariesPaths: string[] =
+      await writeDictionary(contentWithFilePath);
 
     resultDictionariesPaths.push(...dictionariesPaths);
   }

package/src/transpiler/{intlater_module_to_dictionary → declaration_file_to_dictionary/intlayer_dictionary}/extractNestedJSON.ts

@@ -43,7 +43,7 @@ export const extractObjectsWithId = (input: ContentModule): ContentModule[] => {
   // Function to recursively search and extract nested objects with an 'id'
   const search = (obj: Content, results: ContentModule[]): void => {
     if (obj && typeof obj === 'object') {
-      if (Object.prototype.hasOwnProperty.call(obj, 'id')) {
+      if (Object.hasOwn(obj, 'id')) {
         results.push(obj as ContentModule);
       }
       for (const key of Object.keys(obj)) {

package/src/transpiler/declaration_file_to_dictionary/intlayer_dictionary/index.ts

@@ -0,0 +1,3 @@
+export * from './extractNestedJSON';
+export * from './processContentDeclaration';
+export * from './buildIntlayerDictionary';

package/src/transpiler/{intlater_module_to_dictionary/processModule.ts → declaration_file_to_dictionary/intlayer_dictionary/processContentDeclaration.ts}

@@ -22,13 +22,12 @@ const processFunctionResults = async (entry: Content): Promise<FlatContent> => {
         result[key] = (await processFunctionResults(
           field as Content
         )) as FlatContentValue;
-      }
-
-      if (typeof field === 'function') {
+      } else if (typeof field === 'function') {
         // Wait for the function to resolve if it's an async function
         const promise = (async () => {
           // Execute the function and await the result if it's a Promise
           const value = await field();
+
           result[key] = value as FlatContentValue;
         })();
         promises.push(promise);

package/src/transpiler/dictionary_to_type/createModuleAugmentation.ts

@@ -6,7 +6,7 @@ import { getFileHash, transformToCamelCase } from '../../utils';
 
 const { content, internationalization } = getConfiguration();
 const { typesDir, moduleAugmentationDir } = content;
-const { locales } = internationalization;
+const { locales, strictMode } = internationalization;
 
 export const getTypeName = (id: string): string =>
   transformToCamelCase(`${id}Content`);
@@ -15,8 +15,7 @@ export const getTypeName = (id: string): string =>
  * This function generates the content of the module augmentation file
  */
 const generateTypeIndexContent = (typeFiles: string[]): string => {
-  let content =
-    "/* eslint-disable */\nimport 'intlayer';\nimport { Locales } from '@intlayer/config'\n";
+  let content = "/* eslint-disable */\nimport { Locales } from 'intlayer'\n";
 
   const dictionariesRef = typeFiles.map((dictionaryPath) => ({
     relativePath: relative(moduleAugmentationDir, dictionaryPath),
@@ -41,11 +40,18 @@ const generateTypeIndexContent = (typeFiles: string[]): string => {
     .map((locale) => {
       for (const key in Locales) {
         if (Locales[key as keyof typeof Locales] === locale) {
-          return `    ${key} = '${locale}'`;
+          return `Locales.${key}`;
         }
       }
     })
-    .join(',\n');
+    .join(' | ');
+
+  const strictModeRecord =
+    strictMode === 'strict'
+      ? `interface IConfigLocales<Content> extends Record<ExtractedLocales, Content> {}`
+      : strictMode === 'required_only'
+        ? `interface IConfigLocales<Content> extends Record<ExtractedLocales, Content>, Partial<Record<ExcludedLocales, Content>> {}`
+        : `interface IConfigLocales<Content> extends Partial<Record<Locales, Content>> {}`;
 
   /**
    * Write the module augmentation to extend the intlayer module with the dictionaries types
@@ -58,22 +64,23 @@ const generateTypeIndexContent = (typeFiles: string[]): string => {
    *     }
    *   }
    *
-   *   enum ConfigLocales {
-   *     ENGLISH = 'en',
-   *     FRENCH = 'fr',
-   *     SPANISH = 'es',
-   *   }
+   *   type ConfigLocales = Locales.ENGLISH | Locales.FRENCH | Locales.SPANISH;
+   *   type ExtractedLocales = Extract<Locales, ConfigLocales>;
+   *   type ExcludedLocales = Exclude<Locales, ConfigLocales>;
+   *
+   *   interface IConfigLocales<Content> extends Record<ExtractedLocales, Content>, Partial<Record<ExcludedLocales, Content>> {}
    *
-   *   interface IConfigLocales<Content> extends Record<ConfigLocales, Content> {}
    *
    * }
    * See https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
    */
   content += `declare module 'intlayer' {\n`;
   content += `  interface IntlayerDictionaryTypesConnector {\n${formattedDictionaryMap}\n  }\n\n`;
-  content += `  enum ConfigLocales {\n${formatLocales}\n  };\n\n`;
-  content += `  interface IConfigLocales<Content> extends Record<ConfigLocales, Content> {}\n`;
-  content += `};`;
+  content += `  type ConfigLocales = ${formatLocales};\n`;
+  content += `  type ExtractedLocales = Extract<Locales, ConfigLocales>;\n`;
+  content += `  type ExcludedLocales = Exclude<Locales, ConfigLocales>;\n\n`;
+  content += `  ${strictModeRecord}\n`;
+  content += `}`;
 
   return content;
 };