@intlayer/chokidar 1.2.0

package/src/transpiler/intlater_module_to_dictionary/loadContentDeclaration.ts

@@ -0,0 +1,114 @@
+/* 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/intlater_module_to_dictionary/processModule.ts

@@ -0,0 +1,66 @@
+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;
+      }
+
+      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/intlater_module_to_dictionary/transpileContentDeclaration.ts

@@ -0,0 +1,62 @@
+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 './processModule';
+
+const { content } = getConfiguration();
+const { dictionariesDir } = content;
+
+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 transpileContentDeclaration = 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 dictionariesPaths: string[] = await buildDictionary(nestedContent);
+
+    resultDictionariesPaths.push(...dictionariesPaths);
+  }
+
+  return resultDictionariesPaths;
+};

package/src/utils.ts

@@ -0,0 +1,26 @@
+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('');
+};