@intlayer/chokidar 1.2.0

package/dist/esm/utils.mjs

@@ -0,0 +1,20 @@
+import crypto from "crypto-js";
+const getFileHash = (filePath) => {
+  const hash = crypto.SHA3(filePath);
+  return hash.toString(crypto.enc.Base64).replace(/[^A-Z\d]/gi, "").substring(0, 20);
+};
+const transformToCamelCase = (string) => {
+  const words = string.split(/[\s\-_]+/);
+  const camelCasedWords = words.map((word, index) => {
+    if (index === 0) {
+      return word[0].toUpperCase() + word.slice(1);
+    }
+    return word.charAt(0).toUpperCase() + word.slice(1);
+  });
+  return camelCasedWords.join("");
+};
+export {
+  getFileHash,
+  transformToCamelCase
+};
+//# sourceMappingURL=utils.mjs.map

package/dist/esm/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils.ts"],"sourcesContent":["import crypto from 'crypto-js';\n\nexport const getFileHash = (filePath: string) => {\n  const hash = crypto.SHA3(filePath);\n\n  return hash\n    .toString(crypto.enc.Base64)\n    .replace(/[^A-Z\\d]/gi, '')\n    .substring(0, 20);\n};\n\nexport const transformToCamelCase = (string: string): string => {\n  // Split the string into words using a regex that finds spaces, hyphens, and underscores\n  const words = string.split(/[\\s\\-_]+/);\n\n  // Transform each word except the first to have its first letter uppercase\n  const camelCasedWords = words.map((word, index) => {\n    if (index === 0) {\n      return word[0].toUpperCase() + word.slice(1);\n    }\n    return word.charAt(0).toUpperCase() + word.slice(1);\n  });\n\n  // Join the words back together\n  return camelCasedWords.join('');\n};\n"],"mappings":"AAAA,OAAO,YAAY;AAEZ,MAAM,cAAc,CAAC,aAAqB;AAC/C,QAAM,OAAO,OAAO,KAAK,QAAQ;AAEjC,SAAO,KACJ,SAAS,OAAO,IAAI,MAAM,EAC1B,QAAQ,cAAc,EAAE,EACxB,UAAU,GAAG,EAAE;AACpB;AAEO,MAAM,uBAAuB,CAAC,WAA2B;AAE9D,QAAM,QAAQ,OAAO,MAAM,UAAU;AAGrC,QAAM,kBAAkB,MAAM,IAAI,CAAC,MAAM,UAAU;AACjD,QAAI,UAAU,GAAG;AACf,aAAO,KAAK,CAAC,EAAE,YAAY,IAAI,KAAK,MAAM,CAAC;AAAA,IAC7C;AACA,WAAO,KAAK,OAAO,CAAC,EAAE,YAAY,IAAI,KAAK,MAAM,CAAC;AAAA,EACpD,CAAC;AAGD,SAAO,gBAAgB,KAAK,EAAE;AAChC;","names":[]}

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@intlayer/chokidar",
+  "version": "1.2.0",
+  "private": false,
+  "description": "Chokidar application for IntLayer - Transpile IntLayer declaration files into dictionaries.",
+  "keywords": [
+    "intlayer",
+    "chokidar",
+    "application",
+    "transpile",
+    "typescript",
+    "javascript",
+    "json",
+    "file"
+  ],
+  "homepage": "https://github.com/aypineau/intlayer",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aypineau/intlayer.git"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Aymeric PINEAU",
+    "url": "https://github.com/aypineau"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.mts",
+      "require": "./dist/cjs/index.cjs",
+      "import": "./dist/esm/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "src/index.ts",
+  "typesVersions": {
+    "*": {
+      "package.json": [
+        "./package.json"
+      ]
+    }
+  },
+  "files": [
+    "./dist",
+    "./src",
+    "./bin",
+    "./package.json"
+  ],
+  "dependencies": {
+    "chokidar": "^3.6.0",
+    "crypto-js": "^4.2.0",
+    "esbuild": "^0.20.2",
+    "esbuild-loader": "^4.1.0",
+    "glob": "^10.3.12",
+    "node-loader": "^2.0.0",
+    "rimraf": "5.0.5",
+    "@intlayer/config": "^1.2.0",
+    "@intlayer/core": "^1.2.0",
+    "intlayer": "^1.2.0"
+  },
+  "devDependencies": {
+    "@changesets/cli": "2.27.1",
+    "@types/crypto-js": "^4.2.2",
+    "@types/node": "^20.12.7",
+    "node-polyfill-webpack-plugin": "^3.0.0",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.5",
+    "webpack-watch-files-plugin": "^1.2.1",
+    "@utils/eslint-config": "^1.0.1",
+    "@utils/ts-config": "^1.0.1"
+  },
+  "engines": {
+    "node": ">=14.18"
+  },
+  "bug": {
+    "url": "https://github.com/aypineau/intlayer/issues"
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "rimraf ./dist",
+    "dev": "tsup --watch",
+    "lint": "eslint . --ext .ts,.tsx,.js,.jsx,.cjs,.mjs",
+    "lint:fix": "eslint . --ext .ts,.tsx,.js,.jsx,.cjs,.mjs --fix",
+    "prettier:fix": "prettier --write src/**/*"
+  }
+}

package/src/chokidar/index.ts

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

package/src/chokidar/watcher.ts

@@ -0,0 +1,84 @@
+import { relative } from 'path';
+import { getConfiguration } from '@intlayer/config';
+import chokidar, { type WatchOptions } from 'chokidar';
+import { sync } from 'glob';
+import { createDictionaryList } from '../transpiler/dictionary_to_main/createDictionaryList';
+import {
+  createTypes,
+  createModuleAugmentation,
+} from '../transpiler/dictionary_to_type/index';
+import { transpileContentDeclaration } from '../transpiler/intlater_module_to_dictionary/transpileContentDeclaration';
+
+// Initialize chokidar watcher (non-persistent)
+export const watch = (options?: WatchOptions) => {
+  const { content } = getConfiguration({
+    verbose: true,
+  });
+  const { watchedFilesPatternWithPath, baseDir } = content;
+
+  const files: string[] = sync(watchedFilesPatternWithPath);
+
+  return chokidar
+    .watch(watchedFilesPatternWithPath, {
+      persistent: true, // Make the watcher persistent
+      ignoreInitial: true, // Process existing files
+      ...options,
+    })
+    .on('ready', async () => {
+      const dictionariesPaths = await transpileContentDeclaration(files);
+
+      console.info('Building Intlayer types...');
+      createTypes(dictionariesPaths);
+
+      console.info('Building Intlayer module augmentation...');
+      createModuleAugmentation();
+
+      console.info('Building Intlayer dictionary list...');
+      createDictionaryList();
+
+      const relativeDictionariesPath = dictionariesPaths.map((dictionary) =>
+        relative(baseDir, dictionary)
+      );
+
+      console.info('Dictionaries:', relativeDictionariesPath);
+    })
+    .on('unlink', (filePath) => {
+      // Process the file with the functionToRun
+      console.info('Removed file detected: ', relative(baseDir, filePath));
+      // await transpileContentDeclaration(filePath);
+
+      // console.info('Building TypeScript types...');
+      // createTypes([filePath]);
+
+      // console.info('Building type index...');
+      // createModuleAugmentation();
+
+      // console.info('Building main...');
+      // createDictionaryList();
+    })
+    .on('add', async (filePath) => {
+      // Process the file with the functionToRun
+      console.info('Additional file detected: ', relative(baseDir, filePath));
+      const dictionaries = await transpileContentDeclaration(filePath);
+
+      console.info('Building TypeScript types...');
+      createTypes(dictionaries);
+
+      console.info('Building type index...');
+      createModuleAugmentation();
+
+      console.info('Building main...');
+      createDictionaryList();
+    })
+    .on('change', async (filePath) => {
+      // Process the file with the functionToRun
+      console.info('Change detected: ', relative(baseDir, filePath));
+      const dictionaries = await transpileContentDeclaration(filePath);
+
+      console.info('Building TypeScript types...');
+      createTypes(dictionaries);
+    })
+    .on('error', (error) => {
+      console.error('Watcher error:', error);
+    });
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+export { watch } from './chokidar/watcher';
+export { createDictionaryList } from './transpiler/dictionary_to_main/createDictionaryList';
+export { createModuleAugmentation } from './transpiler/dictionary_to_type/createModuleAugmentation';

package/src/transpiler/dictionary_to_main/createDictionaryList.ts

@@ -0,0 +1,65 @@
+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

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

package/src/transpiler/dictionary_to_type/createModuleAugmentation.ts

@@ -0,0 +1,95 @@
+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 } = 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 'intlayer';\nimport { Locales } from '@intlayer/config'\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 `    ${key} = '${locale}'`;
+        }
+      }
+    })
+    .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;
+   *     }
+   *   }
+   *
+   *   enum ConfigLocales {
+   *     ENGLISH = 'en',
+   *     FRENCH = 'fr',
+   *     SPANISH = 'es',
+   *   }
+   *
+   *   interface IConfigLocales<Content> extends Record<ConfigLocales, 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 += `  enum ConfigLocales {\n${formatLocales}\n  };\n\n`;
+  content += `  interface IConfigLocales<Content> extends Record<ConfigLocales, Content> {}\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

@@ -0,0 +1,145 @@
+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;
+};
+
+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;
+    type ValueKey = keyof typeof value;
+
+    if (
+      // Check if the value is a typed node
+      typeof value === 'object' &&
+      nodeType === NodeType.Translation
+    ) {
+      const tsType =
+        typeof 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 =
+        typeof value?.[internationalization.defaultLocale as ValueKey];
+
+      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 = 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

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

package/src/transpiler/intlater_module_to_dictionary/extractNestedJSON.ts

@@ -0,0 +1,60 @@
+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

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