@intlayer/chokidar 2.0.0 → 2.0.1

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

@@ -1,114 +0,0 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-import { createRequire } from 'module';
-import { type Context, runInNewContext } from 'vm';
-import type { ContentModule } from '@intlayer/core';
-import { type BuildOptions, buildSync, type BuildResult } from 'esbuild';
-
-const isESModule = typeof import.meta.url === 'string';
-
-const sandboxContext: Context = {
-  exports: {
-    default: {},
-  },
-  module: {
-    exports: {},
-  },
-  console,
-  require: isESModule ? createRequire(import.meta.url) : require,
-};
-
-const transformationOption: BuildOptions = {
-  loader: {
-    '.js': 'js',
-    '.jsx': 'jsx',
-    '.mjs': 'js',
-    '.ts': 'ts',
-    '.tsx': 'tsx',
-    '.cjs': 'js',
-    '.json': 'json',
-  },
-  format: 'cjs', // Output format as commonjs
-  target: 'es2017',
-  packages: 'external',
-  write: false,
-  bundle: true,
-};
-
-const filterValidContentDeclaration = (
-  contentDeclaration: ContentModule
-): ContentModule => {
-  // @TODO Implement filtering of valid content declaration
-  return contentDeclaration;
-};
-
-/**
- * Load the content declaration from the given path
- *
- * Accepts JSON, JS, MJS and TS files as configuration
- */
-export const loadContentDeclaration = (
-  contentDeclarationFilePath: string
-): ContentModule | undefined => {
-  let contentDeclaration: ContentModule | undefined = undefined;
-
-  const fileExtension = contentDeclarationFilePath.split('.').pop() ?? '';
-
-  try {
-    if (fileExtension === 'json') {
-      // Assume JSON
-      return require(contentDeclarationFilePath);
-    }
-
-    // Rest is JS, MJS or TS
-
-    const moduleResult: BuildResult = buildSync({
-      entryPoints: [contentDeclarationFilePath],
-
-      ...transformationOption,
-    });
-
-    const moduleResultString = moduleResult.outputFiles?.[0].text;
-
-    if (!moduleResultString) {
-      console.error('Configuration file could not be loaded.');
-      return undefined;
-    }
-
-    runInNewContext(moduleResultString, sandboxContext);
-
-    if (
-      sandboxContext.exports.default &&
-      Object.keys(sandboxContext.exports.default).length > 0
-    ) {
-      // ES Module
-      contentDeclaration = sandboxContext.exports.default;
-    } else if (
-      sandboxContext.module.exports.defaults &&
-      Object.keys(sandboxContext.module.exports.defaults).length > 0
-    ) {
-      // CommonJS
-      contentDeclaration = sandboxContext.module.exports.default;
-    } else if (
-      sandboxContext.module.exports.default &&
-      Object.keys(sandboxContext.module.exports.default).length > 0
-    ) {
-      // ES Module
-      contentDeclaration = sandboxContext.module.exports.default;
-    } else if (
-      sandboxContext.module.exports &&
-      Object.keys(sandboxContext.module.exports).length > 0
-    ) {
-      // Other
-      contentDeclaration = sandboxContext.module.exports;
-    }
-
-    if (typeof contentDeclaration === 'undefined') {
-      console.error('Configuration file could not be loaded.');
-      return undefined;
-    }
-
-    return filterValidContentDeclaration(contentDeclaration);
-  } catch (error) {
-    console.error('Error:', error);
-  }
-};

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

@@ -1,65 +0,0 @@
-import { resolve } from 'path';
-import type {
-  Content,
-  ContentModule,
-  FlatContent,
-  FlatContentValue,
-} from '@intlayer/core';
-import { loadContentDeclaration } from './loadContentDeclaration';
-
-/**
- * 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;
-      } else if (typeof field === 'function') {
-        // Wait for the function to resolve if it's an async function
-        const promise = (async () => {
-          // Execute the function and await the result if it's a Promise
-          const value = await field();
-
-          result[key] = value as FlatContentValue;
-        })();
-        promises.push(promise);
-      } 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 processContentDeclaration = async (file: string) => {
-  try {
-    const functionPath = resolve(file);
-    const entry = loadContentDeclaration(functionPath);
-
-    if (!entry) {
-      console.error('No entry found in module:', functionPath);
-      return;
-    }
-
-    return (await processFunctionResults(entry)) as ContentModule;
-  } catch (error) {
-    console.error('Error processing module:', error);
-  }
-};

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,102 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
-import { basename, join, relative } from 'path';
-import { Locales, getConfiguration } from '@intlayer/config';
-import { sync } from 'glob';
-import { getFileHash, transformToCamelCase } from '../../utils';
-
-const { content, internationalization } = getConfiguration();
-const { typesDir, moduleAugmentationDir } = content;
-const { locales, strictMode } = internationalization;
-
-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 = "/* eslint-disable */\nimport { Locales } from 'intlayer'\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');
-
-  const formatLocales = locales
-    .map((locale) => {
-      for (const key in Locales) {
-        if (Locales[key as keyof typeof Locales] === locale) {
-          return `Locales.${key}`;
-        }
-      }
-    })
-    .join(' | ');
-
-  const strictModeRecord =
-    strictMode === 'strict'
-      ? `interface IConfigLocales<Content> extends Record<ExtractedLocales, Content> {}`
-      : strictMode === 'required_only'
-        ? `interface IConfigLocales<Content> extends Record<ExtractedLocales, Content>, Partial<Record<ExcludedLocales, Content>> {}`
-        : `interface IConfigLocales<Content> extends Partial<Record<Locales, Content>> {}`;
-
-  /**
-   * Write the module augmentation to extend the intlayer module with the dictionaries types
-   * Will suggest the type resulting of the dictionaries
-   *
-   * declare module 'intlayer' {
-   *   interface IntlayerDictionaryTypesConnector = {
-   *     dictionaries: {
-   *       id: DictionaryType;
-   *     }
-   *   }
-   *
-   *   type ConfigLocales = Locales.ENGLISH | Locales.FRENCH | Locales.SPANISH;
-   *   type ExtractedLocales = Extract<Locales, ConfigLocales>;
-   *   type ExcludedLocales = Exclude<Locales, ConfigLocales>;
-   *
-   *   interface IConfigLocales<Content> extends Record<ExtractedLocales, Content>, Partial<Record<ExcludedLocales, Content>> {}
-   *
-   *
-   * }
-   * See https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
-   */
-  content += `declare module 'intlayer' {\n`;
-  content += `  interface IntlayerDictionaryTypesConnector {\n${formattedDictionaryMap}\n  }\n\n`;
-  content += `  type ConfigLocales = ${formatLocales};\n`;
-  content += `  type ExtractedLocales = Extract<Locales, ConfigLocales>;\n`;
-  content += `  type ExcludedLocales = Exclude<Locales, ConfigLocales>;\n\n`;
-  content += `  ${strictModeRecord}\n`;
-  content += `}`;
-
-  return content;
-};
-
-/**
- * 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,162 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
-import { createRequire } from 'module';
-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;
-
-const isESModule = typeof import.meta.url === 'string';
-const requireFunction = isESModule ? createRequire(import.meta.url) : require;
-
-/**
- *
- * 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;
-};
-
-const isReactNode = (node: Record<string, unknown>): boolean =>
-  typeof node?.key !== 'undefined' && typeof node?.props !== 'undefined';
-
-// eslint-disable-next-line sonarjs/cognitive-complexity
-export const generateTypeScriptTypeContent = (obj: Content): string => {
-  if (typeof obj !== 'object' || obj === null) {
-    return `${typeof obj}`;
-  }
-
-  const isReactNodeValue = isReactNode(obj as Record<string, unknown>);
-
-  if (isReactNodeValue) {
-    // ReactNode handling
-    return `JSX.Element`;
-  }
-
-  let typeDefinition = ``;
-  for (const [key, value] of Object.entries(obj)) {
-    const nodeType: NodeType | undefined = (value as TypedNode)?.nodeType;
-    type ValueKey = keyof typeof value;
-
-    if (
-      // Check if the value is a typed node
-      typeof value === 'object' &&
-      nodeType === NodeType.Translation
-    ) {
-      const tsType = generateTypeScriptTypeContent(
-        value?.[internationalization.defaultLocale as ValueKey]
-      );
-      typeDefinition += `  ${key}: ${tsType},\n`;
-    } else if (
-      // Check if the value is a typed node
-      typeof value === 'object' &&
-      nodeType === NodeType.Enumeration
-    ) {
-      const tsType = generateTypeScriptTypeContent(
-        value?.[internationalization.defaultLocale as ValueKey] as Content
-      );
-
-      typeDefinition += `  ${key}: (quantity: number) => ${tsType},\n`;
-    } else if (
-      // Check if the value is a nested object
-      typeof value === 'object'
-    ) {
-      const isArray = Array.isArray(value);
-
-      if (isArray) {
-        // Array handling (simplified, assumes non-empty arrays with uniform type)
-        const arrayType = generateTypeScriptTypeContent(value as Content);
-
-        typeDefinition += `  ${key}: ${arrayType}[],\n`;
-      } else {
-        // Nested object, recurse
-        const nestedType = generateTypeScriptTypeContent(value as Content);
-
-        typeDefinition += `  ${key}: {${nestedType}},\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 = requireFunction(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/utils.ts

@@ -1,26 +0,0 @@
-import crypto from 'crypto-js';
-
-export const getFileHash = (filePath: string) => {
-  const hash = crypto.SHA3(filePath);
-
-  return hash
-    .toString(crypto.enc.Base64)
-    .replace(/[^A-Z\d]/gi, '')
-    .substring(0, 20);
-};
-
-export const transformToCamelCase = (string: string): string => {
-  // Split the string into words using a regex that finds spaces, hyphens, and underscores
-  const words = string.split(/[\s\-_]+/);
-
-  // Transform each word except the first to have its first letter uppercase
-  const camelCasedWords = words.map((word, index) => {
-    if (index === 0) {
-      return word[0].toUpperCase() + word.slice(1);
-    }
-    return word.charAt(0).toUpperCase() + word.slice(1);
-  });
-
-  // Join the words back together
-  return camelCasedWords.join('');
-};