@intlayer/chokidar 2.0.0 → 2.0.2

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

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

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

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

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

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

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

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

package/src/transpiler/declaration_file_to_dictionary/index.ts

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

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

@@ -1,70 +0,0 @@
-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 { processContentDeclaration } from './processContentDeclaration';
-
-const { content } = getConfiguration();
-const { dictionariesDir } = content;
-
-const writeDictionary = 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 buildIntlayerDictionary = async (
-  contentDeclarationsPaths: string[] | string
-) => {
-  const resultDictionariesPaths: string[] = [];
-
-  if (typeof contentDeclarationsPaths === 'string') {
-    contentDeclarationsPaths = [contentDeclarationsPaths];
-  }
-
-  // Create the dictionaries folder if it doesn't exist
-  await mkdir(resolve(dictionariesDir), { recursive: true });
-
-  for await (const contentDeclarationPath of contentDeclarationsPaths) {
-    const result = await processContentDeclaration(contentDeclarationPath);
-
-    if (!result) {
-      continue;
-    }
-
-    const nestedContent: ContentModule[] = extractObjectsWithId(result);
-
-    const contentWithFilePath: ContentModule[] = nestedContent.map(
-      (content) => ({
-        ...content,
-        filePath: contentDeclarationPath,
-      })
-    );
-
-    const dictionariesPaths: string[] =
-      await writeDictionary(contentWithFilePath);
-
-    resultDictionariesPaths.push(...dictionariesPaths);
-  }
-
-  return resultDictionariesPaths;
-};

package/src/transpiler/declaration_file_to_dictionary/intlayer_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.hasOwn(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/declaration_file_to_dictionary/intlayer_dictionary/index.ts

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

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';