@intlayer/webpack 1.0.0 → 1.2.0

package/dist/esm/transpiler/intlater_module_to_dictionary/processModule.mjs

@@ -1,39 +0,0 @@
-import { resolve } from "path";
-const loadModule = async (modulePath) => {
-  return (await import(modulePath)).default;
-};
-const processFunctionResults = async (entry) => {
-  if (entry && typeof entry === "object") {
-    const promises = [];
-    const result = {};
-    for (const key of Object.keys(entry)) {
-      const field = entry?.[key];
-      if (typeof field === "object") {
-        result[key] = await processFunctionResults(field);
-      }
-      if (typeof field === "function") {
-        const promise = (async () => {
-          const value = await field();
-          result[key] = value;
-        })();
-        promises.push(promise);
-      } else {
-        result[key] = field;
-      }
-    }
-    await Promise.all(promises);
-    return result;
-  }
-  return entry;
-};
-const processModule = async (file) => {
-  try {
-    const functionPath = resolve(file);
-    const entry = await loadModule(functionPath);
-    return await processFunctionResults(entry);
-  } catch (error) {
-    console.error("Error processing module:", error);
-  }
-};
-export { processModule };
-//# sourceMappingURL=processModule.mjs.map

package/dist/esm/transpiler/intlater_module_to_dictionary/processModule.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/transpiler/intlater_module_to_dictionary/processModule.ts"],"sourcesContent":["import { resolve } from 'path';\nimport type {\n  Content,\n  ContentModule,\n  FlatContent,\n  FlatContentValue,\n} from '@intlayer/core';\n\n/**\n * Function to load the module file in a sandboxed environment\n */\nconst loadModule = async (modulePath: string): Promise<ContentModule> => {\n  // @TODO: Sandbox the module to prevent malicious code execution\n\n  return (await import(modulePath)).default;\n};\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      }\n\n      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          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 processModule = async (file: string) => {\n  try {\n    const functionPath = resolve(file);\n    const entry = await loadModule(functionPath);\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;AAWxB,MAAM,aAAa,OAAO,eAA+C;AAGvE,UAAQ,MAAM,OAAO,aAAa;AACpC;AAKA,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;AAEA,UAAI,OAAO,UAAU,YAAY;AAE/B,cAAM,WAAW,YAAY;AAE3B,gBAAM,QAAQ,MAAM,MAAM;AAC1B,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,gBAAgB,OAAO,SAAiB;AACnD,MAAI;AACF,UAAM,eAAe,QAAQ,IAAI;AACjC,UAAM,QAAQ,MAAM,WAAW,YAAY;AAE3C,WAAQ,MAAM,uBAAuB,KAAK;AAAA,EAC5C,SAAS,OAAO;AACd,YAAQ,MAAM,4BAA4B,KAAK;AAAA,EACjD;AACF;","names":[]}

package/dist/esm/transpiler/intlater_module_to_dictionary/transpileBundledCode.d.mts

@@ -1,8 +0,0 @@
-/**
- * This function transpile the bundled code to to make dictionaries as JSON files
- */
-declare const transpileBundledCode: (
-  bundledEntriesPaths: string[] | string
-) => Promise<string[]>;
-
-export { transpileBundledCode };

package/dist/esm/transpiler/intlater_module_to_dictionary/transpileBundledCode.mjs

@@ -1,70 +0,0 @@
-import { existsSync } from "fs";
-import { mkdir, writeFile } from "fs/promises";
-import { resolve } from "path";
-import { getConfiguration } from "@intlayer/config";
-import { extractObjectsWithId } from "./extractNestedJSON.mjs";
-import { processModule } from "./processModule.mjs";
-const { content } = getConfiguration();
-const { dictionariesDir, bundleFileExtension } = content;
-const loadBundledModule = async (bundledEntryPath) => {
-  const entryFilePath = resolve(bundledEntryPath);
-  const isEntryFilePathExist = existsSync(entryFilePath);
-  if (!isEntryFilePathExist) {
-    console.error("Entry file not found. " + entryFilePath);
-    return;
-  }
-  const isEntryPathValid = entryFilePath.endsWith(bundleFileExtension);
-  if (!isEntryPathValid) {
-    return;
-  }
-  try {
-    delete require.cache[entryFilePath];
-    const entry = await import(entryFilePath);
-    let result;
-    if (entry.default) {
-      result = await processModule(entryFilePath);
-    } else {
-      result = entry;
-    }
-    return result;
-  } catch (err) {
-    console.error(`Error transpiling ${entryFilePath}:`, err);
-  }
-};
-const buildDictionary = async (dictionaries) => {
-  const resultDictionariesPaths = [];
-  for await (const content2 of dictionaries) {
-    const contentString = JSON.stringify(content2);
-    const id = content2.id;
-    const outputFileName = `${id}.json`;
-    const resultFilePath = resolve(dictionariesDir, outputFileName);
-    await writeFile(resultFilePath, contentString, "utf8").catch((err) => {
-      console.error(`Error creating ${outputFileName}:`, err);
-    });
-    resultDictionariesPaths.push(resultFilePath);
-  }
-  return resultDictionariesPaths;
-};
-const transpileBundledCode = async (bundledEntriesPaths) => {
-  const resultDictionariesPaths = [];
-  if (typeof bundledEntriesPaths === "string") {
-    bundledEntriesPaths = [bundledEntriesPaths];
-  }
-  const filteredBundledEntriesPaths = bundledEntriesPaths.filter(
-    // Filter js files;
-    (bundledEntryPath) => bundledEntryPath.endsWith(bundleFileExtension)
-  );
-  await mkdir(resolve(dictionariesDir), { recursive: true });
-  for await (const bundledEntryPath of filteredBundledEntriesPaths) {
-    const result = await loadBundledModule(bundledEntryPath);
-    if (!result) {
-      continue;
-    }
-    const nestedContent = extractObjectsWithId(result);
-    const dictionariesPaths = await buildDictionary(nestedContent);
-    resultDictionariesPaths.push(...dictionariesPaths);
-  }
-  return resultDictionariesPaths;
-};
-export { transpileBundledCode };
-//# sourceMappingURL=transpileBundledCode.mjs.map

package/dist/esm/transpiler/intlater_module_to_dictionary/transpileBundledCode.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/transpiler/intlater_module_to_dictionary/transpileBundledCode.ts"],"sourcesContent":["import { existsSync } from 'fs';\nimport { mkdir, writeFile } from 'fs/promises';\nimport { resolve } from 'path';\nimport { getConfiguration } from '@intlayer/config';\nimport type { ContentModule } from '@intlayer/core';\nimport { extractObjectsWithId } from './extractNestedJSON';\nimport { processModule } from './processModule';\n\nconst { content } = getConfiguration();\nconst { dictionariesDir, bundleFileExtension } = content;\n\nconst loadBundledModule = async (bundledEntryPath: string) => {\n  const entryFilePath = resolve(bundledEntryPath);\n\n  const isEntryFilePathExist = existsSync(entryFilePath);\n\n  if (!isEntryFilePathExist) {\n    console.error('Entry file not found. ' + entryFilePath);\n    return;\n  }\n\n  const isEntryPathValid = entryFilePath.endsWith(bundleFileExtension);\n\n  if (!isEntryPathValid) {\n    return;\n  }\n\n  try {\n    // Remove the module from the cache\n    delete require.cache[entryFilePath];\n\n    // Require the module anew\n    const entry = await import(entryFilePath);\n\n    let result: ContentModule | undefined;\n\n    if (entry.default) {\n      // JS or TS file\n      result = await processModule(entryFilePath);\n    } else {\n      // JSON file\n      result = entry;\n    }\n\n    return result;\n  } catch (err) {\n    console.error(`Error transpiling ${entryFilePath}:`, err);\n  }\n};\n\nconst buildDictionary = async (dictionaries: ContentModule[]) => {\n  const resultDictionariesPaths: string[] = [];\n\n  for await (const content of dictionaries) {\n    const contentString = JSON.stringify(content);\n\n    const id = content.id;\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\n/**\n * This function transpile the bundled code to to make dictionaries as JSON files\n */\nexport const transpileBundledCode = async (\n  bundledEntriesPaths: string[] | string\n) => {\n  const resultDictionariesPaths: string[] = [];\n\n  if (typeof bundledEntriesPaths === 'string') {\n    bundledEntriesPaths = [bundledEntriesPaths];\n  }\n\n  const filteredBundledEntriesPaths: string[] = bundledEntriesPaths.filter(\n    // Filter js files;\n    (bundledEntryPath) => bundledEntryPath.endsWith(bundleFileExtension)\n  );\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(dictionariesDir), { recursive: true });\n\n  for await (const bundledEntryPath of filteredBundledEntriesPaths) {\n    const result = await loadBundledModule(bundledEntryPath);\n\n    if (!result) {\n      continue;\n    }\n\n    const nestedContent: ContentModule[] = extractObjectsWithId(result);\n\n    const dictionariesPaths: string[] = await buildDictionary(nestedContent);\n\n    resultDictionariesPaths.push(...dictionariesPaths);\n  }\n\n  return resultDictionariesPaths;\n};\n"],"mappings":"AAAA,SAAS,kBAAkB;AAC3B,SAAS,OAAO,iBAAiB;AACjC,SAAS,eAAe;AACxB,SAAS,wBAAwB;AAEjC,SAAS,4BAA4B;AACrC,SAAS,qBAAqB;AAE9B,MAAM,EAAE,QAAQ,IAAI,iBAAiB;AACrC,MAAM,EAAE,iBAAiB,oBAAoB,IAAI;AAEjD,MAAM,oBAAoB,OAAO,qBAA6B;AAC5D,QAAM,gBAAgB,QAAQ,gBAAgB;AAE9C,QAAM,uBAAuB,WAAW,aAAa;AAErD,MAAI,CAAC,sBAAsB;AACzB,YAAQ,MAAM,2BAA2B,aAAa;AACtD;AAAA,EACF;AAEA,QAAM,mBAAmB,cAAc,SAAS,mBAAmB;AAEnE,MAAI,CAAC,kBAAkB;AACrB;AAAA,EACF;AAEA,MAAI;AAEF,WAAO,QAAQ,MAAM,aAAa;AAGlC,UAAM,QAAQ,MAAM,OAAO;AAE3B,QAAI;AAEJ,QAAI,MAAM,SAAS;AAEjB,eAAS,MAAM,cAAc,aAAa;AAAA,IAC5C,OAAO;AAEL,eAAS;AAAA,IACX;AAEA,WAAO;AAAA,EACT,SAAS,KAAK;AACZ,YAAQ,MAAM,qBAAqB,aAAa,KAAK,GAAG;AAAA,EAC1D;AACF;AAEA,MAAM,kBAAkB,OAAO,iBAAkC;AAC/D,QAAM,0BAAoC,CAAC;AAE3C,mBAAiBA,YAAW,cAAc;AACxC,UAAM,gBAAgB,KAAK,UAAUA,QAAO;AAE5C,UAAM,KAAKA,SAAQ;AACnB,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;AAKO,MAAM,uBAAuB,OAClC,wBACG;AACH,QAAM,0BAAoC,CAAC;AAE3C,MAAI,OAAO,wBAAwB,UAAU;AAC3C,0BAAsB,CAAC,mBAAmB;AAAA,EAC5C;AAEA,QAAM,8BAAwC,oBAAoB;AAAA;AAAA,IAEhE,CAAC,qBAAqB,iBAAiB,SAAS,mBAAmB;AAAA,EACrE;AAGA,QAAM,MAAM,QAAQ,eAAe,GAAG,EAAE,WAAW,KAAK,CAAC;AAEzD,mBAAiB,oBAAoB,6BAA6B;AAChE,UAAM,SAAS,MAAM,kBAAkB,gBAAgB;AAEvD,QAAI,CAAC,QAAQ;AACX;AAAA,IACF;AAEA,UAAM,gBAAiC,qBAAqB,MAAM;AAElE,UAAM,oBAA8B,MAAM,gBAAgB,aAAa;AAEvE,4BAAwB,KAAK,GAAG,iBAAiB;AAAA,EACnD;AAEA,SAAO;AACT;","names":["content"]}

package/src/scripts/bundle.ts

@@ -1,44 +0,0 @@
-import type { Compiler } from 'webpack';
-
-export const bundle = (compiler: Compiler) =>
-  // Run the compiler
-  compiler.run((err, stats) => {
-    // Handle errors and webpack compilation stats
-    if (err) {
-      console.error('Webpack compilation error:', err);
-      return;
-    }
-
-    console.info('Webpack compilation successful.');
-
-    if (stats)
-      console.info(
-        stats.toString({
-          // Add options here to customize the stats output
-          colors: true,
-        })
-      );
-  });
-
-export const watch = (compiler: Compiler) =>
-  // Run the compiler
-  compiler.watch({}, (err, stats) => {
-    // Handle errors and webpack compilation stats
-    if (err) {
-      console.error('Webpack compilation error:', err);
-      return;
-    }
-
-    console.info('Webpack compilation successful.');
-
-    if (stats)
-      console.info(
-        stats.toString({
-          // Add options here to customize the stats output
-          colors: true,
-        })
-      );
-
-    // After successful compilation, start the server
-    console.info('Watch IntLayer content...');
-  });

package/src/scripts/index.ts

@@ -1,2 +0,0 @@
-export * from './startServer';
-export * from './bundle';

package/src/scripts/startServer.ts

@@ -1,14 +0,0 @@
-import type { Compiler } from 'webpack';
-import { devServerConfig } from '../webpack.config';
-
-const WebpackDevServer = require('webpack-dev-server');
-
-export const startServer = (compiler: Compiler) => {
-  // Create a new instance of webpack-dev-server
-  const devServer = new WebpackDevServer(devServerConfig, compiler);
-
-  // Start the server
-  devServer.startCallback(() => {
-    console.info('Webpack Dev Server is running...');
-  });
-};

package/src/transpiler/dictionary_to_main/createDictionaryList.ts

@@ -1,65 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
-import { basename, extname, relative, resolve } from 'path';
-import { getConfiguration } from '@intlayer/config';
-import { sync } from 'glob';
-import { getFileHash } from '../../utils';
-
-const { content } = getConfiguration();
-const { dictionariesDir, mainDir } = content;
-
-/**
- * This function generates the content of the dictionary list file
- */
-const generateDictionaryListContent = (
-  dictionaries: string[],
-  format: 'cjs' | 'esm' = 'esm'
-): string => {
-  let content = '';
-
-  const dictionariesRef = dictionaries.map((dictionaryPath) => ({
-    relativePath: relative(mainDir, dictionaryPath),
-    id: basename(dictionaryPath, extname(dictionaryPath)), // Get the base name as the dictionary id
-    hash: `_${getFileHash(dictionaryPath)}`, // Get the hash of the dictionary to avoid conflicts
-  }));
-
-  // Import all dictionaries
-  dictionariesRef.forEach((dictionary) => {
-    if (format === 'esm')
-      content += `import ${dictionary.hash} from '${dictionary.relativePath}';\n`;
-    if (format === 'cjs')
-      content += `const ${dictionary.hash} = require('${dictionary.relativePath}');\n`;
-  });
-
-  content += '\n';
-
-  // Format Dictionary Map
-  const formattedDictionaryMap: string = dictionariesRef
-    .map((dictionary) => `"${dictionary.id}": ${dictionary.hash}`)
-    .join(',\n');
-
-  if (format === 'esm')
-    content += `export default {\n${formattedDictionaryMap}\n};\n`;
-  if (format === 'cjs')
-    content += `module.exports = {\n${formattedDictionaryMap}\n};\n`;
-
-  return content;
-};
-
-/**
- * This function generates a list of dictionaries in the main directory
- */
-export const createDictionaryList = () => {
-  // Create main directory if it doesn't exist
-  if (!existsSync(mainDir)) {
-    mkdirSync(mainDir, { recursive: true });
-  }
-
-  const dictionaries: string[] = sync(`${dictionariesDir}/**/*.json`);
-
-  // Create the dictionary list file
-  const cjsContent = generateDictionaryListContent(dictionaries, 'cjs');
-  writeFileSync(resolve(mainDir, 'dictionaries.cjs'), cjsContent);
-
-  const esmContent = generateDictionaryListContent(dictionaries, 'esm');
-  writeFileSync(resolve(mainDir, 'dictionaries.mjs'), esmContent);
-};

package/src/transpiler/dictionary_to_main/index.ts

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

package/src/transpiler/dictionary_to_type/createModuleAugmentation.ts

@@ -1,70 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
-import { basename, join, relative } from 'path';
-import { getConfiguration } from '@intlayer/config';
-import { sync } from 'glob';
-import { getFileHash, transformToCamelCase } from '../../utils';
-
-const { content } = getConfiguration();
-const { typesDir, moduleAugmentationDir } = content;
-
-export const getTypeName = (id: string): string =>
-  transformToCamelCase(`${id}Content`);
-
-/**
- * This function generates the content of the module augmentation file
- */
-const generateTypeIndexContent = (typeFiles: string[]): string => {
-  let content = "import 'intlayer';\n\n";
-
-  const dictionariesRef = typeFiles.map((dictionaryPath) => ({
-    relativePath: relative(moduleAugmentationDir, dictionaryPath),
-    id: basename(dictionaryPath, '.d.ts'), // Get the base name as the dictionary id
-    hash: `_${getFileHash(dictionaryPath)}`, // Get the hash of the dictionary to avoid conflicts
-  }));
-
-  // Import all dictionaries
-  dictionariesRef.forEach((dictionary) => {
-    const typeName = getTypeName(dictionary.id);
-    content += `import type { ${typeName} as ${dictionary.hash} } from '${dictionary.relativePath}';\n`;
-  });
-
-  content += '\n';
-
-  // Format Dictionary Map
-  const formattedDictionaryMap: string = dictionariesRef
-    .map((dictionary) => `    "${dictionary.id}": ${dictionary.hash};`)
-    .join('\n');
-
-  /**
-   * Write the module augmentation to extend the intlayer module with the dictionaries types
-   * Will suggest the type resulting of the dictionaries
-   *
-   * declare module 'intlayer' {
-   *   interface IntlayerDictionaryTypesConnector = {
-   *     dictionaries: {
-   *       id: DictionaryType;
-   *     }
-   * }
-   *
-   * See https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
-   */
-  content += `declare module 'intlayer' {\n  interface IntlayerDictionaryTypesConnector {\n${formattedDictionaryMap}\n  };\n};`;
-
-  return content;
-};
-
-/**
- * This function generates a index file merging all the types
- */
-export const createModuleAugmentation = () => {
-  // Create main directory if it doesn't exist
-  if (!existsSync(moduleAugmentationDir)) {
-    mkdirSync(moduleAugmentationDir, { recursive: true });
-  }
-
-  const dictionaries: string[] = sync(`${typesDir}/**/*.d.ts`);
-  // Create the dictionary list file
-
-  const tsContent = generateTypeIndexContent(dictionaries);
-  writeFileSync(join(moduleAugmentationDir, 'intlayer.d.ts'), tsContent);
-};

package/src/transpiler/dictionary_to_type/createType.ts

@@ -1,140 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
-import { resolve } from 'path';
-import { getConfiguration } from '@intlayer/config';
-import {
-  NodeType,
-  type Content,
-  type ContentModule,
-  type TypedNode,
-} from '@intlayer/core';
-import { getTypeName } from './createModuleAugmentation';
-
-const { content, internationalization } = getConfiguration();
-const { typesDir } = content;
-
-/**
- *
- * This function generates a TypeScript type definition from a JSON object
- *
- * Example:
- *
- * const input = {
- *  id: '1',
- *  name: 'John Doe',
- *  address: {
- *      id: '2',
- *      street: '123 Main St',
- *      city: 'Springfield',
- *  }
- * };
- *
- * const result = generateTypeScriptType(input, 'RootObject');
- * console.log(result);
- *
- * Output:
- *
- * type RootObject = {
- *  id: '1',
- *  name: string,
- *  address: {
- *      id: '2',
- *      street: string,
- *      city: string,
- *  },
- * };
- *
- */
-export const generateTypeScriptType = (obj: ContentModule): string => {
-  let typeDefinition = ``;
-
-  const typeName = getTypeName(obj.id);
-
-  typeDefinition += `export type ${typeName} = {\n`;
-  typeDefinition += generateTypeScriptTypeContent(obj);
-  typeDefinition += '};\n\n';
-
-  return typeDefinition;
-};
-
-export const generateTypeScriptTypeContent = (obj: Content): string => {
-  let typeDefinition = ``;
-
-  for (const [key, value] of Object.entries(obj)) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const nodeType: NodeType | undefined = (value as TypedNode).nodeType;
-
-    if (
-      // Check if the value is a typed node
-      typeof value === 'object' &&
-      nodeType === NodeType.Translation
-    ) {
-      const tsType =
-        typeof value[internationalization.defaultLocale as keyof typeof value];
-      typeDefinition += `  ${key}: ${tsType},\n`;
-    } else if (
-      // Check if the value is a typed node
-      typeof value === 'object' &&
-      nodeType === NodeType.Enumeration
-    ) {
-      const tsType =
-        typeof value[internationalization.defaultLocale as keyof typeof value];
-
-      typeDefinition += `  ${key}: (quantity: number) => ${tsType},\n`;
-    } else if (
-      // Check if the value is a nested object
-      typeof value === 'object' &&
-      !Array.isArray(value)
-    ) {
-      // Nested object, recurse
-      const nestedType = generateTypeScriptTypeContent(value as Content);
-      typeDefinition += `  ${key}: {${nestedType}},\n`;
-    } else if (
-      // Check if the value is an array
-      Array.isArray(value)
-    ) {
-      // Array handling (simplified, assumes non-empty arrays with uniform type)
-      const arrayType = typeof value[0];
-      typeDefinition += `  ${key}: ${arrayType}[],\n`;
-    } else if (
-      // Check if the value is an 'id'
-      typeof value === 'string' &&
-      key === 'id'
-    ) {
-      // Special handling for 'id' field
-      const tsType = `"${value}"`;
-      typeDefinition += `  ${key}: ${tsType},\n`;
-    } else {
-      // Primitive type
-      const tsType = typeof value;
-      typeDefinition += `  ${key}: ${tsType},\n`;
-    }
-  }
-
-  return typeDefinition;
-};
-
-/**
- * This function generates a TypeScript type definition from a JSON object
- */
-export const createTypes = (dictionariesPaths: string[]): string[] => {
-  const resultTypesPaths: string[] = [];
-
-  // Create type folders if they don't exist
-  if (!existsSync(typesDir)) {
-    mkdirSync(typesDir, { recursive: true });
-  }
-
-  for (const dictionaryPath of dictionariesPaths) {
-    const contentModule: ContentModule = require(dictionaryPath);
-    const dictionaryName: string = contentModule.id;
-    const typeDefinition: string = generateTypeScriptType(contentModule);
-
-    const outputPath = resolve(typesDir, `${dictionaryName}.d.ts`);
-
-    writeFileSync(outputPath, typeDefinition);
-
-    resultTypesPaths.push(outputPath);
-  }
-
-  return resultTypesPaths;
-};

package/src/transpiler/dictionary_to_type/index.ts

@@ -1,2 +0,0 @@
-export * from './createModuleAugmentation';
-export * from './createType';

package/src/transpiler/intlater_module_to_dictionary/extractNestedJSON.ts

@@ -1,60 +0,0 @@
-import type { Content, ContentModule } from '@intlayer/core';
-
-/**
- *
- * This function extracts all nested objects with an 'id' field from the input object and returns them as an array
- *
- * Example:
- *
- * const input = {
- *  id: '1',
- *  name: 'John Doe',
- *  address: {
- *    id: '2',
- *    street: '123 Main St',
- *    city: 'Springfield',
- *    state: 'IL'
- *  },
- * };
- * const result = extractObjectsWithId(input);
- * console.log(result);
- *
- * Output:
- *
- * [{
- *  id: '1',
- *  name: 'John Doe',
- *  address: {
- *    id: '2',
- *    street: '123 Main St',
- *    city: 'Springfield',
- *    state: 'IL'
- *  }
- * },
- * {
- *  id: '2',
- *  street: '123 Main St',
- *  city: 'Springfield',
- *  state: 'IL'
- * }]
- *
- */
-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')) {
-        results.push(obj as ContentModule);
-      }
-      for (const key of Object.keys(obj)) {
-        if (typeof obj[key] === 'object') {
-          search(obj[key] as Content, results);
-        }
-      }
-    }
-  };
-
-  const results: ContentModule[] = [];
-  search(input, results);
-  return results;
-};

package/src/transpiler/intlater_module_to_dictionary/index.ts

@@ -1,3 +0,0 @@
-export * from './extractNestedJSON';
-export * from './processModule';
-export * from './transpileBundledCode';

package/src/transpiler/intlater_module_to_dictionary/processModule.ts

@@ -1,69 +0,0 @@
-import { resolve } from 'path';
-import type {
-  Content,
-  ContentModule,
-  FlatContent,
-  FlatContentValue,
-} from '@intlayer/core';
-
-/**
- * Function to load the module file in a sandboxed environment
- */
-const loadModule = async (modulePath: string): Promise<ContentModule> => {
-  // @TODO: Sandbox the module to prevent malicious code execution
-
-  return (await import(modulePath)).default;
-};
-
-/**
- * Function to replace function and async function fields with their results in the object
- */
-const processFunctionResults = async (entry: Content): Promise<FlatContent> => {
-  if (entry && typeof entry === 'object') {
-    const promises: Promise<void>[] = [];
-    const result: FlatContent = {};
-
-    for (const key of Object.keys(entry)) {
-      const field = entry?.[key];
-
-      if (typeof field === 'object') {
-        result[key] = (await processFunctionResults(
-          field as Content
-        )) as FlatContentValue;
-      }
-
-      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);
-      } else {
-        result[key] = field as FlatContentValue;
-      }
-    }
-
-    // Wait for all async operations to complete
-    await Promise.all(promises);
-
-    return result;
-  }
-
-  return entry;
-};
-
-/**
- * Function to load, process the module and return the Intlayer ContentModule from the module file
- */
-export const processModule = async (file: string) => {
-  try {
-    const functionPath = resolve(file);
-    const entry = await loadModule(functionPath);
-
-    return (await processFunctionResults(entry)) as ContentModule;
-  } catch (error) {
-    console.error('Error processing module:', error);
-  }
-};