@intlayer/webpack 1.0.1 → 1.2.0

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);
-  }
-};

package/src/transpiler/intlater_module_to_dictionary/transpileBundledCode.ts

@@ -1,107 +0,0 @@
-import { existsSync } from 'fs';
-import { mkdir, writeFile } from 'fs/promises';
-import { resolve } from 'path';
-import { getConfiguration } from '@intlayer/config';
-import type { ContentModule } from '@intlayer/core';
-import { extractObjectsWithId } from './extractNestedJSON';
-import { processModule } from './processModule';
-
-const { content } = getConfiguration();
-const { dictionariesDir, bundleFileExtension } = content;
-
-const loadBundledModule = async (bundledEntryPath: string) => {
-  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 {
-    // Remove the module from the cache
-    delete require.cache[entryFilePath];
-
-    // Require the module anew
-    const entry = await import(entryFilePath);
-
-    let result: ContentModule | undefined;
-
-    if (entry.default) {
-      // JS or TS file
-      result = await processModule(entryFilePath);
-    } else {
-      // JSON file
-      result = entry;
-    }
-
-    return result;
-  } catch (err) {
-    console.error(`Error transpiling ${entryFilePath}:`, err);
-  }
-};
-
-const buildDictionary = async (dictionaries: ContentModule[]) => {
-  const resultDictionariesPaths: string[] = [];
-
-  for await (const content of dictionaries) {
-    const contentString = JSON.stringify(content);
-
-    const id = content.id;
-    const outputFileName = `${id}.json`;
-    const resultFilePath = resolve(dictionariesDir, outputFileName);
-
-    // Create the json file
-    await writeFile(resultFilePath, contentString, 'utf8').catch((err) => {
-      console.error(`Error creating ${outputFileName}:`, err);
-    });
-
-    resultDictionariesPaths.push(resultFilePath);
-  }
-
-  return resultDictionariesPaths;
-};
-
-/**
- * This function transpile the bundled code to to make dictionaries as JSON files
- */
-export const transpileBundledCode = async (
-  bundledEntriesPaths: string[] | string
-) => {
-  const resultDictionariesPaths: string[] = [];
-
-  if (typeof bundledEntriesPaths === 'string') {
-    bundledEntriesPaths = [bundledEntriesPaths];
-  }
-
-  const filteredBundledEntriesPaths: string[] = bundledEntriesPaths.filter(
-    // Filter js files;
-    (bundledEntryPath) => bundledEntryPath.endsWith(bundleFileExtension)
-  );
-
-  // Create the dictionaries folder if it doesn't exist
-  await mkdir(resolve(dictionariesDir), { recursive: true });
-
-  for await (const bundledEntryPath of filteredBundledEntriesPaths) {
-    const result = await loadBundledModule(bundledEntryPath);
-
-    if (!result) {
-      continue;
-    }
-
-    const nestedContent: ContentModule[] = extractObjectsWithId(result);
-
-    const dictionariesPaths: string[] = await buildDictionary(nestedContent);
-
-    resultDictionariesPaths.push(...dictionariesPaths);
-  }
-
-  return resultDictionariesPaths;
-};