@intlayer/chokidar 4.1.3 → 4.1.5

package/README.md

@@ -20,7 +20,7 @@
 
 **Intlayer** is a suite of packages designed specifically for JavaScript developers. It is compatible with frameworks like React, React, and Express.js.
 
-The **`@intlayer/chokidar`** package is used to scan and build Intlayer declaration files into dictionaries using [chokidar](https://github.com/paulmillr/chokidar) and according to the [Intlayer configuration](https://intlayer.org//doc/concept/configuration).
+The **`@intlayer/chokidar`** package is used to scan and build Intlayer declaration files into dictionaries using [chokidar](https://github.com/paulmillr/chokidar) and according to the [Intlayer configuration](https://intlayer.org/doc/concept/configuration).
 
 ## Usage
 

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

@@ -28,7 +28,10 @@ const { dictionariesDir } = (0, import_config.getConfiguration)().content;
 const writeDictionary = async (dictionaries) => {
   const resultDictionariesPaths = [];
   for await (const dictionaryContent of dictionaries) {
-    const contentString = JSON.stringify(dictionaryContent);
+    const contentString = JSON.stringify({
+      $schema: "https://intlayer.org/schema.json",
+      ...dictionaryContent
+    });
     const id = dictionaryContent.key;
     const outputFileName = `${id}.json`;
     const resultFilePath = (0, import_path.resolve)(dictionariesDir, outputFileName);

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeDictionary.ts"],"sourcesContent":["import { writeFile } from 'fs/promises';\nimport { resolve } from 'path';\nimport { getConfiguration } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\n\nconst { dictionariesDir } = getConfiguration().content;\n\nexport const writeDictionary = async (dictionaries: Dictionary[]) => {\n  const resultDictionariesPaths: string[] = [];\n\n  for await (const dictionaryContent of dictionaries) {\n    const contentString = JSON.stringify(dictionaryContent);\n\n    const id = dictionaryContent.key;\n    const outputFileName = `${id}.json`;\n    const resultFilePath = resolve(dictionariesDir, outputFileName);\n\n    // Create the json file\n    await writeFile(resultFilePath, contentString, 'utf8').catch((err) => {\n      console.error(`Error creating ${outputFileName}:`, err);\n    });\n\n    resultDictionariesPaths.push(resultFilePath);\n  }\n\n  return resultDictionariesPaths;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sBAA0B;AAC1B,kBAAwB;AACxB,oBAAiC;AAGjC,MAAM,EAAE,gBAAgB,QAAI,gCAAiB,EAAE;AAExC,MAAM,kBAAkB,OAAO,iBAA+B;AACnE,QAAM,0BAAoC,CAAC;AAE3C,mBAAiB,qBAAqB,cAAc;AAClD,UAAM,gBAAgB,KAAK,UAAU,iBAAiB;AAEtD,UAAM,KAAK,kBAAkB;AAC7B,UAAM,iBAAiB,GAAG,EAAE;AAC5B,UAAM,qBAAiB,qBAAQ,iBAAiB,cAAc;AAG9D,cAAM,2BAAU,gBAAgB,eAAe,MAAM,EAAE,MAAM,CAAC,QAAQ;AACpE,cAAQ,MAAM,kBAAkB,cAAc,KAAK,GAAG;AAAA,IACxD,CAAC;AAED,4BAAwB,KAAK,cAAc;AAAA,EAC7C;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../../../../src/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeDictionary.ts"],"sourcesContent":["import { writeFile } from 'fs/promises';\nimport { resolve } from 'path';\nimport { getConfiguration } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\n\nconst { dictionariesDir } = getConfiguration().content;\n\nexport const writeDictionary = async (dictionaries: Dictionary[]) => {\n  const resultDictionariesPaths: string[] = [];\n\n  for await (const dictionaryContent of dictionaries) {\n    const contentString = JSON.stringify({\n      $schema: 'https://intlayer.org/schema.json',\n      ...dictionaryContent,\n    });\n\n    const id = dictionaryContent.key;\n    const outputFileName = `${id}.json`;\n    const resultFilePath = resolve(dictionariesDir, outputFileName);\n\n    // Create the json file\n    await writeFile(resultFilePath, contentString, 'utf8').catch((err) => {\n      console.error(`Error creating ${outputFileName}:`, err);\n    });\n\n    resultDictionariesPaths.push(resultFilePath);\n  }\n\n  return resultDictionariesPaths;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sBAA0B;AAC1B,kBAAwB;AACxB,oBAAiC;AAGjC,MAAM,EAAE,gBAAgB,QAAI,gCAAiB,EAAE;AAExC,MAAM,kBAAkB,OAAO,iBAA+B;AACnE,QAAM,0BAAoC,CAAC;AAE3C,mBAAiB,qBAAqB,cAAc;AAClD,UAAM,gBAAgB,KAAK,UAAU;AAAA,MACnC,SAAS;AAAA,MACT,GAAG;AAAA,IACL,CAAC;AAED,UAAM,KAAK,kBAAkB;AAC7B,UAAM,iBAAiB,GAAG,EAAE;AAC5B,UAAM,qBAAiB,qBAAQ,iBAAiB,cAAc;AAG9D,cAAM,2BAAU,gBAAgB,eAAe,MAAM,EAAE,MAAM,CAAC,QAAQ;AACpE,cAAQ,MAAM,kBAAkB,cAAc,KAAK,GAAG;AAAA,IACxD,CAAC;AAED,4BAAwB,KAAK,cAAc;AAAA,EAC7C;AAEA,SAAO;AACT;","names":[]}

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

@@ -40,11 +40,11 @@ var import_utils = require('../../utils.cjs');
 const { content, internationalization } = (0, import_config.getConfiguration)();
 const { typesDir, moduleAugmentationDir } = content;
 const { locales, strictMode } = internationalization;
-const getTypeName = (id) => (0, import_utils.transformToCamelCase)(`${id}Content`);
+const getTypeName = (key) => `${(0, import_utils.kebabCaseToCamelCase)(key)}Content`;
 const generateTypeIndexContent = (typeFiles) => {
   let content2 = "/* eslint-disable */\nimport { Locales } from 'intlayer';\n";
   const dictionariesRef = typeFiles.map((dictionaryPath) => ({
-    relativePath: (0, import_path.relative)(moduleAugmentationDir, dictionaryPath),
+    relativePath: `./${(0, import_path.relative)(moduleAugmentationDir, dictionaryPath)}`,
     id: (0, import_path.basename)(dictionaryPath, ".d.ts"),
     // Get the base name as the dictionary id
     hash: `_${(0, import_utils.getFileHash)(dictionaryPath)}`

package/dist/cjs/transpiler/dictionary_to_type/createModuleAugmentation.cjs.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 fg from 'fast-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[] = fg.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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAqD;AACrD,kBAAyC;AACzC,oBAA0C;AAC1C,uBAAe;AACf,mBAAkD;AAElD,MAAM,EAAE,SAAS,qBAAqB,QAAI,gCAAiB;AAC3D,MAAM,EAAE,UAAU,sBAAsB,IAAI;AAC5C,MAAM,EAAE,SAAS,WAAW,IAAI;AAEzB,MAAM,cAAc,CAAC,WAC1B,mCAAqB,GAAG,EAAE,SAAS;AAKrC,MAAM,2BAA2B,CAAC,cAAgC;AAChE,MAAIA,WAAU;AAEd,QAAM,kBAAkB,UAAU,IAAI,CAAC,oBAAoB;AAAA,IACzD,kBAAc,sBAAS,uBAAuB,cAAc;AAAA,IAC5D,QAAI,sBAAS,gBAAgB,OAAO;AAAA;AAAA,IACpC,MAAM,QAAI,0BAAY,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,uBAAS;AACzB,UAAI,sBAAQ,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,KAAC,sBAAW,qBAAqB,GAAG;AACtC,6BAAU,uBAAuB,EAAE,WAAW,KAAK,CAAC;AAAA,EACtD;AAEA,QAAM,eAAyB,iBAAAC,QAAG,KAAK,GAAG,QAAQ,YAAY;AAG9D,QAAM,YAAY,yBAAyB,YAAY;AACvD,mCAAc,kBAAK,uBAAuB,eAAe,GAAG,SAAS;AACvE;","names":["content","fg"]}
+{"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 fg from 'fast-glob';\nimport { getFileHash, kebabCaseToCamelCase } from '../../utils';\n\nconst { content, internationalization } = getConfiguration();\nconst { typesDir, moduleAugmentationDir } = content;\nconst { locales, strictMode } = internationalization;\n\nexport const getTypeName = (key: string): string =>\n  `${kebabCaseToCamelCase(key)}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[] = fg.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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAqD;AACrD,kBAAyC;AACzC,oBAA0C;AAC1C,uBAAe;AACf,mBAAkD;AAElD,MAAM,EAAE,SAAS,qBAAqB,QAAI,gCAAiB;AAC3D,MAAM,EAAE,UAAU,sBAAsB,IAAI;AAC5C,MAAM,EAAE,SAAS,WAAW,IAAI;AAEzB,MAAM,cAAc,CAAC,QAC1B,OAAG,mCAAqB,GAAG,CAAC;AAK9B,MAAM,2BAA2B,CAAC,cAAgC;AAChE,MAAIA,WAAU;AAEd,QAAM,kBAAkB,UAAU,IAAI,CAAC,oBAAoB;AAAA,IACzD,cAAc,SAAK,sBAAS,uBAAuB,cAAc,CAAC;AAAA,IAClE,QAAI,sBAAS,gBAAgB,OAAO;AAAA;AAAA,IACpC,MAAM,QAAI,0BAAY,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,uBAAS;AACzB,UAAI,sBAAQ,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,KAAC,sBAAW,qBAAqB,GAAG;AACtC,6BAAU,uBAAuB,EAAE,WAAW,KAAK,CAAC;AAAA,EACtD;AAEA,QAAM,eAAyB,iBAAAC,QAAG,KAAK,GAAG,QAAQ,YAAY;AAG9D,QAAM,YAAY,yBAAyB,YAAY;AACvD,mCAAc,kBAAK,uBAAuB,eAAe,GAAG,SAAS;AACvE;","names":["content","fg"]}

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

@@ -26,18 +26,13 @@ var import_fs = require("fs");
 var import_path = require("path");
 var import_config = require("@intlayer/config");
 var import_quicktype_core = require("quicktype-core");
+var import_utils = require('../../utils.cjs');
 const { content } = (0, import_config.getConfiguration)();
 const { typesDir } = content;
 const requireUncached = (module2) => {
   delete import_config.ESMxCJSRequire.cache[import_config.ESMxCJSRequire.resolve(module2)];
   return (0, import_config.ESMxCJSRequire)(module2);
 };
-const kebabCaseToCamelCase = (name) => name.split(/[\s\-_]+/).map((word, index) => {
-  if (index === 0) {
-    return word;
-  }
-  return word.charAt(0).toUpperCase() + word.slice(1);
-}).join("");
 const generateTypeScriptType = async (typeName, jsonString) => {
   const { lines } = await quicktypeJSON(typeName, jsonString);
   const linesString = lines.join("\n");
@@ -71,17 +66,16 @@ const createTypes = async (dictionariesPaths) => {
   }
   for (const dictionaryPath of dictionariesPaths) {
     const dictionary = requireUncached(dictionaryPath);
-    const dictionaryName = dictionary.key;
-    if (!dictionaryName) {
+    if (!dictionary.key) {
       continue;
     }
-    const dictionaryNameCamelCase = kebabCaseToCamelCase(dictionaryName) + "Content";
+    const dictionaryNameCamelCase = `${(0, import_utils.kebabCaseToCamelCase)(dictionary.key)}Content`;
     const dictionaryContentString = JSON.stringify(dictionary);
     const typeDefinition = await generateTypeScriptType(
       dictionaryNameCamelCase,
       dictionaryContentString
     );
-    const outputPath = (0, import_path.resolve)(typesDir, `${dictionaryName}.d.ts`);
+    const outputPath = (0, import_path.resolve)(typesDir, `${dictionary.key}.d.ts`);
     (0, import_fs.writeFileSync)(outputPath, typeDefinition);
     resultTypesPaths.push(outputPath);
   }

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/transpiler/dictionary_to_type/createType.ts"],"sourcesContent":["import { existsSync, mkdirSync, writeFileSync } from 'fs';\nimport { resolve } from 'path';\nimport { getConfiguration, ESMxCJSRequire } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport {\n  quicktype,\n  InputData,\n  jsonInputForTargetLanguage,\n} from 'quicktype-core';\n\nconst { content } = getConfiguration();\nconst { typesDir } = content;\n\nconst requireUncached = (module: string) => {\n  delete ESMxCJSRequire.cache[ESMxCJSRequire.resolve(module)];\n  return ESMxCJSRequire(module);\n};\n\nconst kebabCaseToCamelCase = (name: string): string =>\n  name\n    .split(/[\\s\\-_]+/) // Regular expression to match space, hyphen, or underscore\n    .map((word, index) => {\n      if (index === 0) {\n        return word; // Return the first word as is\n      }\n      return word.charAt(0).toUpperCase() + word.slice(1); // Capitalize the first letter of subsequent words\n    })\n    .join(''); // Join all the segments into one string\n\nexport const generateTypeScriptType = async (\n  typeName: string,\n  jsonString: string\n) => {\n  const { lines } = await quicktypeJSON(typeName, jsonString);\n\n  const linesString: string = lines.join('\\n');\n\n  return linesString;\n};\n\nconst quicktypeJSON = async (typeName: string, jsonString: string) => {\n  const jsonInput = jsonInputForTargetLanguage('typescript');\n\n  // We could add multiple samples for the same desired\n  // type, or many sources for other types. Here we're\n  // just making one type from one piece of sample JSON.\n\n  await jsonInput.addSource({\n    name: typeName,\n    samples: [jsonString],\n  });\n\n  const inputData = new InputData();\n  inputData.addInput(jsonInput);\n\n  return await quicktype({\n    inputData,\n    lang: 'typescript',\n    alphabetizeProperties: true,\n    rendererOptions: {\n      'just-types': 'true',\n      'explicit-unions': 'true',\n      'acronym-style': 'camel',\n      'prefer-types': 'true',\n      readonly: 'false',\n    },\n  });\n};\n\n/**\n * This function generates a TypeScript type definition from a JSON object\n */\nexport const createTypes = async (\n  dictionariesPaths: string[]\n): Promise<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 dictionary: Dictionary = requireUncached(dictionaryPath);\n\n    const dictionaryName: string = dictionary.key;\n\n    if (!dictionaryName) {\n      // Skip dictionary if it doesn't have a key, if not exported as default etc\n      continue;\n    }\n\n    const dictionaryNameCamelCase: string =\n      kebabCaseToCamelCase(dictionaryName) + 'Content';\n\n    const dictionaryContentString: string = JSON.stringify(dictionary);\n\n    const typeDefinition: string = await generateTypeScriptType(\n      dictionaryNameCamelCase,\n      dictionaryContentString\n    );\n\n    const outputPath: string = resolve(typesDir, `${dictionaryName}.d.ts`);\n\n    writeFileSync(outputPath, typeDefinition);\n\n    resultTypesPaths.push(outputPath);\n  }\n\n  return resultTypesPaths;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAqD;AACrD,kBAAwB;AACxB,oBAAiD;AAEjD,4BAIO;AAEP,MAAM,EAAE,QAAQ,QAAI,gCAAiB;AACrC,MAAM,EAAE,SAAS,IAAI;AAErB,MAAM,kBAAkB,CAACA,YAAmB;AAC1C,SAAO,6BAAe,MAAM,6BAAe,QAAQA,OAAM,CAAC;AAC1D,aAAO,8BAAeA,OAAM;AAC9B;AAEA,MAAM,uBAAuB,CAAC,SAC5B,KACG,MAAM,UAAU,EAChB,IAAI,CAAC,MAAM,UAAU;AACpB,MAAI,UAAU,GAAG;AACf,WAAO;AAAA,EACT;AACA,SAAO,KAAK,OAAO,CAAC,EAAE,YAAY,IAAI,KAAK,MAAM,CAAC;AACpD,CAAC,EACA,KAAK,EAAE;AAEL,MAAM,yBAAyB,OACpC,UACA,eACG;AACH,QAAM,EAAE,MAAM,IAAI,MAAM,cAAc,UAAU,UAAU;AAE1D,QAAM,cAAsB,MAAM,KAAK,IAAI;AAE3C,SAAO;AACT;AAEA,MAAM,gBAAgB,OAAO,UAAkB,eAAuB;AACpE,QAAM,gBAAY,kDAA2B,YAAY;AAMzD,QAAM,UAAU,UAAU;AAAA,IACxB,MAAM;AAAA,IACN,SAAS,CAAC,UAAU;AAAA,EACtB,CAAC;AAED,QAAM,YAAY,IAAI,gCAAU;AAChC,YAAU,SAAS,SAAS;AAE5B,SAAO,UAAM,iCAAU;AAAA,IACrB;AAAA,IACA,MAAM;AAAA,IACN,uBAAuB;AAAA,IACvB,iBAAiB;AAAA,MACf,cAAc;AAAA,MACd,mBAAmB;AAAA,MACnB,iBAAiB;AAAA,MACjB,gBAAgB;AAAA,MAChB,UAAU;AAAA,IACZ;AAAA,EACF,CAAC;AACH;AAKO,MAAM,cAAc,OACzB,sBACsB;AACtB,QAAM,mBAA6B,CAAC;AAGpC,MAAI,KAAC,sBAAW,QAAQ,GAAG;AACzB,6BAAU,UAAU,EAAE,WAAW,KAAK,CAAC;AAAA,EACzC;AAEA,aAAW,kBAAkB,mBAAmB;AAC9C,UAAM,aAAyB,gBAAgB,cAAc;AAE7D,UAAM,iBAAyB,WAAW;AAE1C,QAAI,CAAC,gBAAgB;AAEnB;AAAA,IACF;AAEA,UAAM,0BACJ,qBAAqB,cAAc,IAAI;AAEzC,UAAM,0BAAkC,KAAK,UAAU,UAAU;AAEjE,UAAM,iBAAyB,MAAM;AAAA,MACnC;AAAA,MACA;AAAA,IACF;AAEA,UAAM,iBAAqB,qBAAQ,UAAU,GAAG,cAAc,OAAO;AAErE,iCAAc,YAAY,cAAc;AAExC,qBAAiB,KAAK,UAAU;AAAA,EAClC;AAEA,SAAO;AACT;","names":["module"]}
+{"version":3,"sources":["../../../../src/transpiler/dictionary_to_type/createType.ts"],"sourcesContent":["import { existsSync, mkdirSync, writeFileSync } from 'fs';\nimport { resolve } from 'path';\nimport { getConfiguration, ESMxCJSRequire } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport {\n  quicktype,\n  InputData,\n  jsonInputForTargetLanguage,\n} from 'quicktype-core';\nimport { kebabCaseToCamelCase } from '../../utils';\n\nconst { content } = getConfiguration();\nconst { typesDir } = content;\n\nconst requireUncached = (module: string) => {\n  delete ESMxCJSRequire.cache[ESMxCJSRequire.resolve(module)];\n  return ESMxCJSRequire(module);\n};\n\nexport const generateTypeScriptType = async (\n  typeName: string,\n  jsonString: string\n) => {\n  const { lines } = await quicktypeJSON(typeName, jsonString);\n\n  const linesString: string = lines.join('\\n');\n\n  return linesString;\n};\n\nconst quicktypeJSON = async (typeName: string, jsonString: string) => {\n  const jsonInput = jsonInputForTargetLanguage('typescript');\n\n  // We could add multiple samples for the same desired\n  // type, or many sources for other types. Here we're\n  // just making one type from one piece of sample JSON.\n\n  await jsonInput.addSource({\n    name: typeName,\n    samples: [jsonString],\n  });\n\n  const inputData = new InputData();\n  inputData.addInput(jsonInput);\n\n  return await quicktype({\n    inputData,\n    lang: 'typescript',\n    alphabetizeProperties: true,\n    rendererOptions: {\n      'just-types': 'true',\n      'explicit-unions': 'true',\n      'acronym-style': 'camel',\n      'prefer-types': 'true',\n      readonly: 'false',\n    },\n  });\n};\n\n/**\n * This function generates a TypeScript type definition from a JSON object\n */\nexport const createTypes = async (\n  dictionariesPaths: string[]\n): Promise<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 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 dictionaryNameCamelCase: string = `${kebabCaseToCamelCase(dictionary.key)}Content`;\n\n    const dictionaryContentString: string = JSON.stringify(dictionary);\n\n    const typeDefinition: string = await generateTypeScriptType(\n      dictionaryNameCamelCase,\n      dictionaryContentString\n    );\n\n    const outputPath: string = resolve(typesDir, `${dictionary.key}.d.ts`);\n\n    writeFileSync(outputPath, typeDefinition);\n\n    resultTypesPaths.push(outputPath);\n  }\n\n  return resultTypesPaths;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAqD;AACrD,kBAAwB;AACxB,oBAAiD;AAEjD,4BAIO;AACP,mBAAqC;AAErC,MAAM,EAAE,QAAQ,QAAI,gCAAiB;AACrC,MAAM,EAAE,SAAS,IAAI;AAErB,MAAM,kBAAkB,CAACA,YAAmB;AAC1C,SAAO,6BAAe,MAAM,6BAAe,QAAQA,OAAM,CAAC;AAC1D,aAAO,8BAAeA,OAAM;AAC9B;AAEO,MAAM,yBAAyB,OACpC,UACA,eACG;AACH,QAAM,EAAE,MAAM,IAAI,MAAM,cAAc,UAAU,UAAU;AAE1D,QAAM,cAAsB,MAAM,KAAK,IAAI;AAE3C,SAAO;AACT;AAEA,MAAM,gBAAgB,OAAO,UAAkB,eAAuB;AACpE,QAAM,gBAAY,kDAA2B,YAAY;AAMzD,QAAM,UAAU,UAAU;AAAA,IACxB,MAAM;AAAA,IACN,SAAS,CAAC,UAAU;AAAA,EACtB,CAAC;AAED,QAAM,YAAY,IAAI,gCAAU;AAChC,YAAU,SAAS,SAAS;AAE5B,SAAO,UAAM,iCAAU;AAAA,IACrB;AAAA,IACA,MAAM;AAAA,IACN,uBAAuB;AAAA,IACvB,iBAAiB;AAAA,MACf,cAAc;AAAA,MACd,mBAAmB;AAAA,MACnB,iBAAiB;AAAA,MACjB,gBAAgB;AAAA,MAChB,UAAU;AAAA,IACZ;AAAA,EACF,CAAC;AACH;AAKO,MAAM,cAAc,OACzB,sBACsB;AACtB,QAAM,mBAA6B,CAAC;AAGpC,MAAI,KAAC,sBAAW,QAAQ,GAAG;AACzB,6BAAU,UAAU,EAAE,WAAW,KAAK,CAAC;AAAA,EACzC;AAEA,aAAW,kBAAkB,mBAAmB;AAC9C,UAAM,aAAyB,gBAAgB,cAAc;AAE7D,QAAI,CAAC,WAAW,KAAK;AAEnB;AAAA,IACF;AAEA,UAAM,0BAAkC,OAAG,mCAAqB,WAAW,GAAG,CAAC;AAE/E,UAAM,0BAAkC,KAAK,UAAU,UAAU;AAEjE,UAAM,iBAAyB,MAAM;AAAA,MACnC;AAAA,MACA;AAAA,IACF;AAEA,UAAM,iBAAqB,qBAAQ,UAAU,GAAG,WAAW,GAAG,OAAO;AAErE,iCAAc,YAAY,cAAc;AAExC,qBAAiB,KAAK,UAAU;AAAA,EAClC;AAEA,SAAO;AACT;","names":["module"]}

package/dist/cjs/utils.cjs

@@ -29,8 +29,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var utils_exports = {};
 __export(utils_exports, {
   getFileHash: () => getFileHash,
-  sortAlphabetically: () => sortAlphabetically,
-  transformToCamelCase: () => transformToCamelCase
+  kebabCaseToCamelCase: () => kebabCaseToCamelCase,
+  sortAlphabetically: () => sortAlphabetically
 });
 module.exports = __toCommonJS(utils_exports);
 var import_crypto_js = __toESM(require("crypto-js"));
@@ -38,21 +38,22 @@ const getFileHash = (filePath) => {
   const hash = import_crypto_js.default.SHA3(filePath);
   return hash.toString(import_crypto_js.default.enc.Base64).replace(/[^A-Z\d]/gi, "").substring(0, 20);
 };
-const transformToCamelCase = (string) => {
-  const words = string.split(/[\s\-_]+/);
-  const camelCasedWords = words.map((word, index) => {
-    if (index === 0) {
-      return word[0].toUpperCase() + word.slice(1);
-    }
-    return word.charAt(0).toUpperCase() + word.slice(1);
-  });
-  return camelCasedWords.join("");
+const kebabCaseToCamelCase = (name) => {
+  return name.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((word) => {
+    const lowerWord = word.toLowerCase();
+    let capitalized = lowerWord.charAt(0).toUpperCase() + lowerWord.slice(1);
+    capitalized = capitalized.replace(
+      /(\d)([a-z])/g,
+      (_, number, char) => number + char.toUpperCase()
+    );
+    return capitalized;
+  }).join("");
 };
 const sortAlphabetically = (a, b) => a.localeCompare(b);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getFileHash,
-  sortAlphabetically,
-  transformToCamelCase
+  kebabCaseToCamelCase,
+  sortAlphabetically
 });
 //# sourceMappingURL=utils.cjs.map

package/dist/cjs/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils.ts"],"sourcesContent":["import crypto from 'crypto-js';\n\nexport const getFileHash = (filePath: string) => {\n  const hash = crypto.SHA3(filePath);\n\n  return hash\n    .toString(crypto.enc.Base64)\n    .replace(/[^A-Z\\d]/gi, '')\n    .substring(0, 20);\n};\n\nexport const transformToCamelCase = (string: string): string => {\n  // Split the string into words using a regex that finds spaces, hyphens, and underscores\n  const words = string.split(/[\\s\\-_]+/);\n\n  // Transform each word except the first to have its first letter uppercase\n  const camelCasedWords = words.map((word, index) => {\n    if (index === 0) {\n      return word[0].toUpperCase() + word.slice(1);\n    }\n    return word.charAt(0).toUpperCase() + word.slice(1);\n  });\n\n  // Join the words back together\n  return camelCasedWords.join('');\n};\n\nexport const sortAlphabetically = (a: string, b: string) => a.localeCompare(b);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAmB;AAEZ,MAAM,cAAc,CAAC,aAAqB;AAC/C,QAAM,OAAO,iBAAAA,QAAO,KAAK,QAAQ;AAEjC,SAAO,KACJ,SAAS,iBAAAA,QAAO,IAAI,MAAM,EAC1B,QAAQ,cAAc,EAAE,EACxB,UAAU,GAAG,EAAE;AACpB;AAEO,MAAM,uBAAuB,CAAC,WAA2B;AAE9D,QAAM,QAAQ,OAAO,MAAM,UAAU;AAGrC,QAAM,kBAAkB,MAAM,IAAI,CAAC,MAAM,UAAU;AACjD,QAAI,UAAU,GAAG;AACf,aAAO,KAAK,CAAC,EAAE,YAAY,IAAI,KAAK,MAAM,CAAC;AAAA,IAC7C;AACA,WAAO,KAAK,OAAO,CAAC,EAAE,YAAY,IAAI,KAAK,MAAM,CAAC;AAAA,EACpD,CAAC;AAGD,SAAO,gBAAgB,KAAK,EAAE;AAChC;AAEO,MAAM,qBAAqB,CAAC,GAAW,MAAc,EAAE,cAAc,CAAC;","names":["crypto"]}
+{"version":3,"sources":["../../src/utils.ts"],"sourcesContent":["import crypto from 'crypto-js';\n\nexport const getFileHash = (filePath: string) => {\n  const hash = crypto.SHA3(filePath);\n\n  return hash\n    .toString(crypto.enc.Base64)\n    .replace(/[^A-Z\\d]/gi, '')\n    .substring(0, 20);\n};\n\nexport const kebabCaseToCamelCase = (name: string): string => {\n  return name\n    .split(/[^a-zA-Z0-9]+/) // Split on any non-alphanumeric character\n    .filter(Boolean) // Remove any empty strings\n    .map((word) => {\n      // Convert the entire word to lowercase first\n      const lowerWord = word.toLowerCase();\n\n      // Capitalize the first character\n      let capitalized = lowerWord.charAt(0).toUpperCase() + lowerWord.slice(1);\n\n      // Capitalize any letter that follows a number\n      capitalized = capitalized.replace(\n        /(\\d)([a-z])/g,\n        (_, number, char) => number + char.toUpperCase()\n      );\n\n      return capitalized;\n    })\n    .join(''); // Concatenate all parts into a single string\n};\n\nexport const sortAlphabetically = (a: string, b: string) => a.localeCompare(b);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAmB;AAEZ,MAAM,cAAc,CAAC,aAAqB;AAC/C,QAAM,OAAO,iBAAAA,QAAO,KAAK,QAAQ;AAEjC,SAAO,KACJ,SAAS,iBAAAA,QAAO,IAAI,MAAM,EAC1B,QAAQ,cAAc,EAAE,EACxB,UAAU,GAAG,EAAE;AACpB;AAEO,MAAM,uBAAuB,CAAC,SAAyB;AAC5D,SAAO,KACJ,MAAM,eAAe,EACrB,OAAO,OAAO,EACd,IAAI,CAAC,SAAS;AAEb,UAAM,YAAY,KAAK,YAAY;AAGnC,QAAI,cAAc,UAAU,OAAO,CAAC,EAAE,YAAY,IAAI,UAAU,MAAM,CAAC;AAGvE,kBAAc,YAAY;AAAA,MACxB;AAAA,MACA,CAAC,GAAG,QAAQ,SAAS,SAAS,KAAK,YAAY;AAAA,IACjD;AAEA,WAAO;AAAA,EACT,CAAC,EACA,KAAK,EAAE;AACZ;AAEO,MAAM,qBAAqB,CAAC,GAAW,MAAc,EAAE,cAAc,CAAC;","names":["crypto"]}

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

@@ -5,7 +5,10 @@ const { dictionariesDir } = getConfiguration().content;
 const writeDictionary = async (dictionaries) => {
   const resultDictionariesPaths = [];
   for await (const dictionaryContent of dictionaries) {
-    const contentString = JSON.stringify(dictionaryContent);
+    const contentString = JSON.stringify({
+      $schema: "https://intlayer.org/schema.json",
+      ...dictionaryContent
+    });
     const id = dictionaryContent.key;
     const outputFileName = `${id}.json`;
     const resultFilePath = resolve(dictionariesDir, outputFileName);

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeDictionary.ts"],"sourcesContent":["import { writeFile } from 'fs/promises';\nimport { resolve } from 'path';\nimport { getConfiguration } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\n\nconst { dictionariesDir } = getConfiguration().content;\n\nexport const writeDictionary = async (dictionaries: Dictionary[]) => {\n  const resultDictionariesPaths: string[] = [];\n\n  for await (const dictionaryContent of dictionaries) {\n    const contentString = JSON.stringify(dictionaryContent);\n\n    const id = dictionaryContent.key;\n    const outputFileName = `${id}.json`;\n    const resultFilePath = resolve(dictionariesDir, outputFileName);\n\n    // Create the json file\n    await writeFile(resultFilePath, contentString, 'utf8').catch((err) => {\n      console.error(`Error creating ${outputFileName}:`, err);\n    });\n\n    resultDictionariesPaths.push(resultFilePath);\n  }\n\n  return resultDictionariesPaths;\n};\n"],"mappings":"AAAA,SAAS,iBAAiB;AAC1B,SAAS,eAAe;AACxB,SAAS,wBAAwB;AAGjC,MAAM,EAAE,gBAAgB,IAAI,iBAAiB,EAAE;AAExC,MAAM,kBAAkB,OAAO,iBAA+B;AACnE,QAAM,0BAAoC,CAAC;AAE3C,mBAAiB,qBAAqB,cAAc;AAClD,UAAM,gBAAgB,KAAK,UAAU,iBAAiB;AAEtD,UAAM,KAAK,kBAAkB;AAC7B,UAAM,iBAAiB,GAAG,EAAE;AAC5B,UAAM,iBAAiB,QAAQ,iBAAiB,cAAc;AAG9D,UAAM,UAAU,gBAAgB,eAAe,MAAM,EAAE,MAAM,CAAC,QAAQ;AACpE,cAAQ,MAAM,kBAAkB,cAAc,KAAK,GAAG;AAAA,IACxD,CAAC;AAED,4BAAwB,KAAK,cAAc;AAAA,EAC7C;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../../../../src/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeDictionary.ts"],"sourcesContent":["import { writeFile } from 'fs/promises';\nimport { resolve } from 'path';\nimport { getConfiguration } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\n\nconst { dictionariesDir } = getConfiguration().content;\n\nexport const writeDictionary = async (dictionaries: Dictionary[]) => {\n  const resultDictionariesPaths: string[] = [];\n\n  for await (const dictionaryContent of dictionaries) {\n    const contentString = JSON.stringify({\n      $schema: 'https://intlayer.org/schema.json',\n      ...dictionaryContent,\n    });\n\n    const id = dictionaryContent.key;\n    const outputFileName = `${id}.json`;\n    const resultFilePath = resolve(dictionariesDir, outputFileName);\n\n    // Create the json file\n    await writeFile(resultFilePath, contentString, 'utf8').catch((err) => {\n      console.error(`Error creating ${outputFileName}:`, err);\n    });\n\n    resultDictionariesPaths.push(resultFilePath);\n  }\n\n  return resultDictionariesPaths;\n};\n"],"mappings":"AAAA,SAAS,iBAAiB;AAC1B,SAAS,eAAe;AACxB,SAAS,wBAAwB;AAGjC,MAAM,EAAE,gBAAgB,IAAI,iBAAiB,EAAE;AAExC,MAAM,kBAAkB,OAAO,iBAA+B;AACnE,QAAM,0BAAoC,CAAC;AAE3C,mBAAiB,qBAAqB,cAAc;AAClD,UAAM,gBAAgB,KAAK,UAAU;AAAA,MACnC,SAAS;AAAA,MACT,GAAG;AAAA,IACL,CAAC;AAED,UAAM,KAAK,kBAAkB;AAC7B,UAAM,iBAAiB,GAAG,EAAE;AAC5B,UAAM,iBAAiB,QAAQ,iBAAiB,cAAc;AAG9D,UAAM,UAAU,gBAAgB,eAAe,MAAM,EAAE,MAAM,CAAC,QAAQ;AACpE,cAAQ,MAAM,kBAAkB,cAAc,KAAK,GAAG;AAAA,IACxD,CAAC;AAED,4BAAwB,KAAK,cAAc;AAAA,EAC7C;AAEA,SAAO;AACT;","names":[]}

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

@@ -2,15 +2,15 @@ import { existsSync, mkdirSync, writeFileSync } from "fs";
 import { basename, join, relative } from "path";
 import { Locales, getConfiguration } from "@intlayer/config";
 import fg from "fast-glob";
-import { getFileHash, transformToCamelCase } from "../../utils.mjs";
+import { getFileHash, kebabCaseToCamelCase } from "../../utils.mjs";
 const { content, internationalization } = getConfiguration();
 const { typesDir, moduleAugmentationDir } = content;
 const { locales, strictMode } = internationalization;
-const getTypeName = (id) => transformToCamelCase(`${id}Content`);
+const getTypeName = (key) => `${kebabCaseToCamelCase(key)}Content`;
 const generateTypeIndexContent = (typeFiles) => {
   let content2 = "/* eslint-disable */\nimport { Locales } from 'intlayer';\n";
   const dictionariesRef = typeFiles.map((dictionaryPath) => ({
-    relativePath: relative(moduleAugmentationDir, dictionaryPath),
+    relativePath: `./${relative(moduleAugmentationDir, dictionaryPath)}`,
     id: basename(dictionaryPath, ".d.ts"),
     // Get the base name as the dictionary id
     hash: `_${getFileHash(dictionaryPath)}`

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 fg from 'fast-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[] = fg.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,OAAO,QAAQ;AACf,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,GAAG,KAAK,GAAG,QAAQ,YAAY;AAG9D,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 fg from 'fast-glob';\nimport { getFileHash, kebabCaseToCamelCase } from '../../utils';\n\nconst { content, internationalization } = getConfiguration();\nconst { typesDir, moduleAugmentationDir } = content;\nconst { locales, strictMode } = internationalization;\n\nexport const getTypeName = (key: string): string =>\n  `${kebabCaseToCamelCase(key)}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[] = fg.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,OAAO,QAAQ;AACf,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,QAC1B,GAAG,qBAAqB,GAAG,CAAC;AAK9B,MAAM,2BAA2B,CAAC,cAAgC;AAChE,MAAIA,WAAU;AAEd,QAAM,kBAAkB,UAAU,IAAI,CAAC,oBAAoB;AAAA,IACzD,cAAc,KAAK,SAAS,uBAAuB,cAAc,CAAC;AAAA,IAClE,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,GAAG,KAAK,GAAG,QAAQ,YAAY;AAG9D,QAAM,YAAY,yBAAyB,YAAY;AACvD,gBAAc,KAAK,uBAAuB,eAAe,GAAG,SAAS;AACvE;","names":["content"]}

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

@@ -6,18 +6,13 @@ import {
   InputData,
   jsonInputForTargetLanguage
 } from "quicktype-core";
+import { kebabCaseToCamelCase } from "../../utils.mjs";
 const { content } = getConfiguration();
 const { typesDir } = content;
 const requireUncached = (module) => {
   delete ESMxCJSRequire.cache[ESMxCJSRequire.resolve(module)];
   return ESMxCJSRequire(module);
 };
-const kebabCaseToCamelCase = (name) => name.split(/[\s\-_]+/).map((word, index) => {
-  if (index === 0) {
-    return word;
-  }
-  return word.charAt(0).toUpperCase() + word.slice(1);
-}).join("");
 const generateTypeScriptType = async (typeName, jsonString) => {
   const { lines } = await quicktypeJSON(typeName, jsonString);
   const linesString = lines.join("\n");
@@ -51,17 +46,16 @@ const createTypes = async (dictionariesPaths) => {
   }
   for (const dictionaryPath of dictionariesPaths) {
     const dictionary = requireUncached(dictionaryPath);
-    const dictionaryName = dictionary.key;
-    if (!dictionaryName) {
+    if (!dictionary.key) {
       continue;
     }
-    const dictionaryNameCamelCase = kebabCaseToCamelCase(dictionaryName) + "Content";
+    const dictionaryNameCamelCase = `${kebabCaseToCamelCase(dictionary.key)}Content`;
     const dictionaryContentString = JSON.stringify(dictionary);
     const typeDefinition = await generateTypeScriptType(
       dictionaryNameCamelCase,
       dictionaryContentString
     );
-    const outputPath = resolve(typesDir, `${dictionaryName}.d.ts`);
+    const outputPath = resolve(typesDir, `${dictionary.key}.d.ts`);
     writeFileSync(outputPath, typeDefinition);
     resultTypesPaths.push(outputPath);
   }

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 { resolve } from 'path';\nimport { getConfiguration, ESMxCJSRequire } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport {\n  quicktype,\n  InputData,\n  jsonInputForTargetLanguage,\n} from 'quicktype-core';\n\nconst { content } = getConfiguration();\nconst { typesDir } = content;\n\nconst requireUncached = (module: string) => {\n  delete ESMxCJSRequire.cache[ESMxCJSRequire.resolve(module)];\n  return ESMxCJSRequire(module);\n};\n\nconst kebabCaseToCamelCase = (name: string): string =>\n  name\n    .split(/[\\s\\-_]+/) // Regular expression to match space, hyphen, or underscore\n    .map((word, index) => {\n      if (index === 0) {\n        return word; // Return the first word as is\n      }\n      return word.charAt(0).toUpperCase() + word.slice(1); // Capitalize the first letter of subsequent words\n    })\n    .join(''); // Join all the segments into one string\n\nexport const generateTypeScriptType = async (\n  typeName: string,\n  jsonString: string\n) => {\n  const { lines } = await quicktypeJSON(typeName, jsonString);\n\n  const linesString: string = lines.join('\\n');\n\n  return linesString;\n};\n\nconst quicktypeJSON = async (typeName: string, jsonString: string) => {\n  const jsonInput = jsonInputForTargetLanguage('typescript');\n\n  // We could add multiple samples for the same desired\n  // type, or many sources for other types. Here we're\n  // just making one type from one piece of sample JSON.\n\n  await jsonInput.addSource({\n    name: typeName,\n    samples: [jsonString],\n  });\n\n  const inputData = new InputData();\n  inputData.addInput(jsonInput);\n\n  return await quicktype({\n    inputData,\n    lang: 'typescript',\n    alphabetizeProperties: true,\n    rendererOptions: {\n      'just-types': 'true',\n      'explicit-unions': 'true',\n      'acronym-style': 'camel',\n      'prefer-types': 'true',\n      readonly: 'false',\n    },\n  });\n};\n\n/**\n * This function generates a TypeScript type definition from a JSON object\n */\nexport const createTypes = async (\n  dictionariesPaths: string[]\n): Promise<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 dictionary: Dictionary = requireUncached(dictionaryPath);\n\n    const dictionaryName: string = dictionary.key;\n\n    if (!dictionaryName) {\n      // Skip dictionary if it doesn't have a key, if not exported as default etc\n      continue;\n    }\n\n    const dictionaryNameCamelCase: string =\n      kebabCaseToCamelCase(dictionaryName) + 'Content';\n\n    const dictionaryContentString: string = JSON.stringify(dictionary);\n\n    const typeDefinition: string = await generateTypeScriptType(\n      dictionaryNameCamelCase,\n      dictionaryContentString\n    );\n\n    const outputPath: string = 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,eAAe;AACxB,SAAS,kBAAkB,sBAAsB;AAEjD;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,MAAM,EAAE,QAAQ,IAAI,iBAAiB;AACrC,MAAM,EAAE,SAAS,IAAI;AAErB,MAAM,kBAAkB,CAAC,WAAmB;AAC1C,SAAO,eAAe,MAAM,eAAe,QAAQ,MAAM,CAAC;AAC1D,SAAO,eAAe,MAAM;AAC9B;AAEA,MAAM,uBAAuB,CAAC,SAC5B,KACG,MAAM,UAAU,EAChB,IAAI,CAAC,MAAM,UAAU;AACpB,MAAI,UAAU,GAAG;AACf,WAAO;AAAA,EACT;AACA,SAAO,KAAK,OAAO,CAAC,EAAE,YAAY,IAAI,KAAK,MAAM,CAAC;AACpD,CAAC,EACA,KAAK,EAAE;AAEL,MAAM,yBAAyB,OACpC,UACA,eACG;AACH,QAAM,EAAE,MAAM,IAAI,MAAM,cAAc,UAAU,UAAU;AAE1D,QAAM,cAAsB,MAAM,KAAK,IAAI;AAE3C,SAAO;AACT;AAEA,MAAM,gBAAgB,OAAO,UAAkB,eAAuB;AACpE,QAAM,YAAY,2BAA2B,YAAY;AAMzD,QAAM,UAAU,UAAU;AAAA,IACxB,MAAM;AAAA,IACN,SAAS,CAAC,UAAU;AAAA,EACtB,CAAC;AAED,QAAM,YAAY,IAAI,UAAU;AAChC,YAAU,SAAS,SAAS;AAE5B,SAAO,MAAM,UAAU;AAAA,IACrB;AAAA,IACA,MAAM;AAAA,IACN,uBAAuB;AAAA,IACvB,iBAAiB;AAAA,MACf,cAAc;AAAA,MACd,mBAAmB;AAAA,MACnB,iBAAiB;AAAA,MACjB,gBAAgB;AAAA,MAChB,UAAU;AAAA,IACZ;AAAA,EACF,CAAC;AACH;AAKO,MAAM,cAAc,OACzB,sBACsB;AACtB,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,UAAM,iBAAyB,WAAW;AAE1C,QAAI,CAAC,gBAAgB;AAEnB;AAAA,IACF;AAEA,UAAM,0BACJ,qBAAqB,cAAc,IAAI;AAEzC,UAAM,0BAAkC,KAAK,UAAU,UAAU;AAEjE,UAAM,iBAAyB,MAAM;AAAA,MACnC;AAAA,MACA;AAAA,IACF;AAEA,UAAM,aAAqB,QAAQ,UAAU,GAAG,cAAc,OAAO;AAErE,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 { resolve } from 'path';\nimport { getConfiguration, ESMxCJSRequire } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport {\n  quicktype,\n  InputData,\n  jsonInputForTargetLanguage,\n} from 'quicktype-core';\nimport { kebabCaseToCamelCase } from '../../utils';\n\nconst { content } = getConfiguration();\nconst { typesDir } = content;\n\nconst requireUncached = (module: string) => {\n  delete ESMxCJSRequire.cache[ESMxCJSRequire.resolve(module)];\n  return ESMxCJSRequire(module);\n};\n\nexport const generateTypeScriptType = async (\n  typeName: string,\n  jsonString: string\n) => {\n  const { lines } = await quicktypeJSON(typeName, jsonString);\n\n  const linesString: string = lines.join('\\n');\n\n  return linesString;\n};\n\nconst quicktypeJSON = async (typeName: string, jsonString: string) => {\n  const jsonInput = jsonInputForTargetLanguage('typescript');\n\n  // We could add multiple samples for the same desired\n  // type, or many sources for other types. Here we're\n  // just making one type from one piece of sample JSON.\n\n  await jsonInput.addSource({\n    name: typeName,\n    samples: [jsonString],\n  });\n\n  const inputData = new InputData();\n  inputData.addInput(jsonInput);\n\n  return await quicktype({\n    inputData,\n    lang: 'typescript',\n    alphabetizeProperties: true,\n    rendererOptions: {\n      'just-types': 'true',\n      'explicit-unions': 'true',\n      'acronym-style': 'camel',\n      'prefer-types': 'true',\n      readonly: 'false',\n    },\n  });\n};\n\n/**\n * This function generates a TypeScript type definition from a JSON object\n */\nexport const createTypes = async (\n  dictionariesPaths: string[]\n): Promise<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 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 dictionaryNameCamelCase: string = `${kebabCaseToCamelCase(dictionary.key)}Content`;\n\n    const dictionaryContentString: string = JSON.stringify(dictionary);\n\n    const typeDefinition: string = await generateTypeScriptType(\n      dictionaryNameCamelCase,\n      dictionaryContentString\n    );\n\n    const outputPath: string = resolve(typesDir, `${dictionary.key}.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,eAAe;AACxB,SAAS,kBAAkB,sBAAsB;AAEjD;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,4BAA4B;AAErC,MAAM,EAAE,QAAQ,IAAI,iBAAiB;AACrC,MAAM,EAAE,SAAS,IAAI;AAErB,MAAM,kBAAkB,CAAC,WAAmB;AAC1C,SAAO,eAAe,MAAM,eAAe,QAAQ,MAAM,CAAC;AAC1D,SAAO,eAAe,MAAM;AAC9B;AAEO,MAAM,yBAAyB,OACpC,UACA,eACG;AACH,QAAM,EAAE,MAAM,IAAI,MAAM,cAAc,UAAU,UAAU;AAE1D,QAAM,cAAsB,MAAM,KAAK,IAAI;AAE3C,SAAO;AACT;AAEA,MAAM,gBAAgB,OAAO,UAAkB,eAAuB;AACpE,QAAM,YAAY,2BAA2B,YAAY;AAMzD,QAAM,UAAU,UAAU;AAAA,IACxB,MAAM;AAAA,IACN,SAAS,CAAC,UAAU;AAAA,EACtB,CAAC;AAED,QAAM,YAAY,IAAI,UAAU;AAChC,YAAU,SAAS,SAAS;AAE5B,SAAO,MAAM,UAAU;AAAA,IACrB;AAAA,IACA,MAAM;AAAA,IACN,uBAAuB;AAAA,IACvB,iBAAiB;AAAA,MACf,cAAc;AAAA,MACd,mBAAmB;AAAA,MACnB,iBAAiB;AAAA,MACjB,gBAAgB;AAAA,MAChB,UAAU;AAAA,IACZ;AAAA,EACF,CAAC;AACH;AAKO,MAAM,cAAc,OACzB,sBACsB;AACtB,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,0BAAkC,GAAG,qBAAqB,WAAW,GAAG,CAAC;AAE/E,UAAM,0BAAkC,KAAK,UAAU,UAAU;AAEjE,UAAM,iBAAyB,MAAM;AAAA,MACnC;AAAA,MACA;AAAA,IACF;AAEA,UAAM,aAAqB,QAAQ,UAAU,GAAG,WAAW,GAAG,OAAO;AAErE,kBAAc,YAAY,cAAc;AAExC,qBAAiB,KAAK,UAAU;AAAA,EAClC;AAEA,SAAO;AACT;","names":[]}

package/dist/esm/utils.mjs

@@ -3,20 +3,21 @@ const getFileHash = (filePath) => {
   const hash = crypto.SHA3(filePath);
   return hash.toString(crypto.enc.Base64).replace(/[^A-Z\d]/gi, "").substring(0, 20);
 };
-const transformToCamelCase = (string) => {
-  const words = string.split(/[\s\-_]+/);
-  const camelCasedWords = words.map((word, index) => {
-    if (index === 0) {
-      return word[0].toUpperCase() + word.slice(1);
-    }
-    return word.charAt(0).toUpperCase() + word.slice(1);
-  });
-  return camelCasedWords.join("");
+const kebabCaseToCamelCase = (name) => {
+  return name.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((word) => {
+    const lowerWord = word.toLowerCase();
+    let capitalized = lowerWord.charAt(0).toUpperCase() + lowerWord.slice(1);
+    capitalized = capitalized.replace(
+      /(\d)([a-z])/g,
+      (_, number, char) => number + char.toUpperCase()
+    );
+    return capitalized;
+  }).join("");
 };
 const sortAlphabetically = (a, b) => a.localeCompare(b);
 export {
   getFileHash,
-  sortAlphabetically,
-  transformToCamelCase
+  kebabCaseToCamelCase,
+  sortAlphabetically
 };
 //# sourceMappingURL=utils.mjs.map

package/dist/esm/utils.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils.ts"],"sourcesContent":["import crypto from 'crypto-js';\n\nexport const getFileHash = (filePath: string) => {\n  const hash = crypto.SHA3(filePath);\n\n  return hash\n    .toString(crypto.enc.Base64)\n    .replace(/[^A-Z\\d]/gi, '')\n    .substring(0, 20);\n};\n\nexport const transformToCamelCase = (string: string): string => {\n  // Split the string into words using a regex that finds spaces, hyphens, and underscores\n  const words = string.split(/[\\s\\-_]+/);\n\n  // Transform each word except the first to have its first letter uppercase\n  const camelCasedWords = words.map((word, index) => {\n    if (index === 0) {\n      return word[0].toUpperCase() + word.slice(1);\n    }\n    return word.charAt(0).toUpperCase() + word.slice(1);\n  });\n\n  // Join the words back together\n  return camelCasedWords.join('');\n};\n\nexport const sortAlphabetically = (a: string, b: string) => a.localeCompare(b);\n"],"mappings":"AAAA,OAAO,YAAY;AAEZ,MAAM,cAAc,CAAC,aAAqB;AAC/C,QAAM,OAAO,OAAO,KAAK,QAAQ;AAEjC,SAAO,KACJ,SAAS,OAAO,IAAI,MAAM,EAC1B,QAAQ,cAAc,EAAE,EACxB,UAAU,GAAG,EAAE;AACpB;AAEO,MAAM,uBAAuB,CAAC,WAA2B;AAE9D,QAAM,QAAQ,OAAO,MAAM,UAAU;AAGrC,QAAM,kBAAkB,MAAM,IAAI,CAAC,MAAM,UAAU;AACjD,QAAI,UAAU,GAAG;AACf,aAAO,KAAK,CAAC,EAAE,YAAY,IAAI,KAAK,MAAM,CAAC;AAAA,IAC7C;AACA,WAAO,KAAK,OAAO,CAAC,EAAE,YAAY,IAAI,KAAK,MAAM,CAAC;AAAA,EACpD,CAAC;AAGD,SAAO,gBAAgB,KAAK,EAAE;AAChC;AAEO,MAAM,qBAAqB,CAAC,GAAW,MAAc,EAAE,cAAc,CAAC;","names":[]}
+{"version":3,"sources":["../../src/utils.ts"],"sourcesContent":["import crypto from 'crypto-js';\n\nexport const getFileHash = (filePath: string) => {\n  const hash = crypto.SHA3(filePath);\n\n  return hash\n    .toString(crypto.enc.Base64)\n    .replace(/[^A-Z\\d]/gi, '')\n    .substring(0, 20);\n};\n\nexport const kebabCaseToCamelCase = (name: string): string => {\n  return name\n    .split(/[^a-zA-Z0-9]+/) // Split on any non-alphanumeric character\n    .filter(Boolean) // Remove any empty strings\n    .map((word) => {\n      // Convert the entire word to lowercase first\n      const lowerWord = word.toLowerCase();\n\n      // Capitalize the first character\n      let capitalized = lowerWord.charAt(0).toUpperCase() + lowerWord.slice(1);\n\n      // Capitalize any letter that follows a number\n      capitalized = capitalized.replace(\n        /(\\d)([a-z])/g,\n        (_, number, char) => number + char.toUpperCase()\n      );\n\n      return capitalized;\n    })\n    .join(''); // Concatenate all parts into a single string\n};\n\nexport const sortAlphabetically = (a: string, b: string) => a.localeCompare(b);\n"],"mappings":"AAAA,OAAO,YAAY;AAEZ,MAAM,cAAc,CAAC,aAAqB;AAC/C,QAAM,OAAO,OAAO,KAAK,QAAQ;AAEjC,SAAO,KACJ,SAAS,OAAO,IAAI,MAAM,EAC1B,QAAQ,cAAc,EAAE,EACxB,UAAU,GAAG,EAAE;AACpB;AAEO,MAAM,uBAAuB,CAAC,SAAyB;AAC5D,SAAO,KACJ,MAAM,eAAe,EACrB,OAAO,OAAO,EACd,IAAI,CAAC,SAAS;AAEb,UAAM,YAAY,KAAK,YAAY;AAGnC,QAAI,cAAc,UAAU,OAAO,CAAC,EAAE,YAAY,IAAI,UAAU,MAAM,CAAC;AAGvE,kBAAc,YAAY;AAAA,MACxB;AAAA,MACA,CAAC,GAAG,QAAQ,SAAS,SAAS,KAAK,YAAY;AAAA,IACjD;AAEA,WAAO;AAAA,EACT,CAAC,EACA,KAAK,EAAE;AACZ;AAEO,MAAM,qBAAqB,CAAC,GAAW,MAAc,EAAE,cAAc,CAAC;","names":[]}

package/dist/types/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeDictionary.d.ts","sourceRoot":"","sources":["../../../../../src/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeDictionary.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIjD,eAAO,MAAM,eAAe,iBAAwB,UAAU,EAAE,sBAmB/D,CAAC"}
+{"version":3,"file":"writeDictionary.d.ts","sourceRoot":"","sources":["../../../../../src/transpiler/declaration_file_to_dictionary/intlayer_dictionary/writeDictionary.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIjD,eAAO,MAAM,eAAe,iBAAwB,UAAU,EAAE,sBAsB/D,CAAC"}

package/dist/types/transpiler/dictionary_to_type/createModuleAugmentation.d.ts

@@ -1,4 +1,4 @@
-export declare const getTypeName: (id: string) => string;
+export declare const getTypeName: (key: string) => string;
 /**
  * This function generates a index file merging all the types
  */

package/dist/types/transpiler/dictionary_to_type/createModuleAugmentation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createModuleAugmentation.d.ts","sourceRoot":"","sources":["../../../../src/transpiler/dictionary_to_type/createModuleAugmentation.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,WAAW,OAAQ,MAAM,KAAG,MACH,CAAC;AA4EvC;;GAEG;AACH,eAAO,MAAM,wBAAwB,YAWpC,CAAC"}
+{"version":3,"file":"createModuleAugmentation.d.ts","sourceRoot":"","sources":["../../../../src/transpiler/dictionary_to_type/createModuleAugmentation.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,WAAW,QAAS,MAAM,KAAG,MACH,CAAC;AA4ExC;;GAEG;AACH,eAAO,MAAM,wBAAwB,YAWpC,CAAC"}

package/dist/types/transpiler/dictionary_to_type/createType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createType.d.ts","sourceRoot":"","sources":["../../../../src/transpiler/dictionary_to_type/createType.ts"],"names":[],"mappings":"AA6BA,eAAO,MAAM,sBAAsB,aACvB,MAAM,cACJ,MAAM,oBAOnB,CAAC;AA+BF;;GAEG;AACH,eAAO,MAAM,WAAW,sBACH,MAAM,EAAE,KAC1B,OAAO,CAAC,MAAM,EAAE,CAoClB,CAAC"}
+{"version":3,"file":"createType.d.ts","sourceRoot":"","sources":["../../../../src/transpiler/dictionary_to_type/createType.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,sBAAsB,aACvB,MAAM,cACJ,MAAM,oBAOnB,CAAC;AA+BF;;GAEG;AACH,eAAO,MAAM,WAAW,sBACH,MAAM,EAAE,KAC1B,OAAO,CAAC,MAAM,EAAE,CAiClB,CAAC"}

package/dist/types/utils.d.ts

@@ -1,4 +1,4 @@
 export declare const getFileHash: (filePath: string) => string;
-export declare const transformToCamelCase: (string: string) => string;
+export declare const kebabCaseToCamelCase: (name: string) => string;
 export declare const sortAlphabetically: (a: string, b: string) => number;
 //# sourceMappingURL=utils.d.ts.map

package/dist/types/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,aAAc,MAAM,WAO3C,CAAC;AAEF,eAAO,MAAM,oBAAoB,WAAY,MAAM,KAAG,MAcrD,CAAC;AAEF,eAAO,MAAM,kBAAkB,MAAO,MAAM,KAAK,MAAM,WAAuB,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,aAAc,MAAM,WAO3C,CAAC;AAEF,eAAO,MAAM,oBAAoB,SAAU,MAAM,KAAG,MAoBnD,CAAC;AAEF,eAAO,MAAM,kBAAkB,MAAO,MAAM,KAAK,MAAM,WAAuB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/chokidar",
-  "version": "4.1.3",
+  "version": "4.1.5",
   "private": false,
   "description": "Uses chokidar to scan and build Intlayer declaration files into dictionaries based on Intlayer configuration.",
   "keywords": [
@@ -63,10 +63,10 @@
     "fast-glob": "^3.3.3",
     "p-limit": "^3.1.0",
     "quicktype-core": "^23.0.170",
-    "@intlayer/api": "4.1.3",
-    "@intlayer/core": "4.1.3",
-    "intlayer": "4.1.3",
-    "@intlayer/config": "4.1.3"
+    "@intlayer/api": "4.1.5",
+    "@intlayer/config": "4.1.5",
+    "@intlayer/core": "4.1.5",
+    "intlayer": "4.1.5"
   },
   "devDependencies": {
     "@changesets/cli": "2.27.11",
@@ -80,19 +80,19 @@
     "tsc-alias": "^1.8.10",
     "tsup": "^8.3.5",
     "typescript": "^5.7.3",
-    "@intlayer/backend": "4.1.3",
+    "@intlayer/backend": "4.1.5",
     "@utils/eslint-config": "1.0.4",
     "@utils/ts-config": "1.0.4",
-    "@utils/ts-config-types": "1.0.4",
-    "@utils/tsup-config": "1.0.4"
+    "@utils/tsup-config": "1.0.4",
+    "@utils/ts-config-types": "1.0.4"
   },
   "peerDependencies": {
     "fast-glob": "^3.3.3",
     "react": ">=16.0.0",
-    "@intlayer/core": "4.1.3",
-    "intlayer": "^4.1.3",
-    "@intlayer/config": "4.1.3",
-    "@intlayer/api": "4.1.3"
+    "@intlayer/api": "4.1.5",
+    "@intlayer/config": "4.1.5",
+    "@intlayer/core": "4.1.5",
+    "intlayer": "^4.1.5"
   },
   "engines": {
     "node": ">=14.18"