@kununu/phraseapp-cli 3.1.0-beta.3 → 4.0.0-beta.0

package/check-translations.js

@@ -0,0 +1,115 @@
+//import { readFileSync, writeFileSync, unlinkSync, existsSync } from 'fs';
+//import { sync } from 'glob';
+//import { parse } from '@babel/parser';
+//import traverse from '@babel/traverse';
+
+const { readFileSync, writeFileSync, unlinkSync, existsSync } = require('fs');
+const {sync} = require('glob');
+const {parse} = require('@babel/parser');
+const traverse = require('@babel/traverse');
+
+
+// const TRANSLATIONS_FILE = `${process.cwd()}/translations/de_AT.json`;
+const DYNAMIC_KEYS_FILE = `${process.cwd()}/dynamic_keys.json`;
+const UNUSED_KEYS_FILE = 'not_used_keys.json';
+const MISSING_KEYS_FILE = 'missing_keys.json';
+const POSSIBLE_DYNAMIC_KEYS_FILE = 'possible_dynamic_keys.json';
+
+function extractTranslationKeys() {
+    const files = sync(`${process.env.SOURCE_DIR}/**/**/*.{js,jsx,ts,tsx}`);
+    const keys = new Set();
+    const possibleDynamicKeys = {};
+
+    files.forEach(file => {
+        const content = readFileSync(file, 'utf8');
+        try {
+            const ast = parse(content, { sourceType: 'module', plugins: ['jsx', 'typescript'] });
+            traverse.default(ast, {
+                JSXOpeningElement({ node }) {
+                    if (node.name.name === 'FormattedMessage') {
+                        const idAttr = node.attributes.find(attr => attr.name.name === 'id');
+                        if (idAttr && idAttr.value && idAttr.value.type === 'StringLiteral') {
+                            keys.add(idAttr.value.value);
+                        } else {
+                            possibleDynamicKeys[file] = possibleDynamicKeys[file] || [];
+                        }
+                    }
+                },
+                CallExpression({ node }) {
+                    if (node.callee && node.callee.property && ['formatMessage'].includes(node.callee.property.name)) {
+                        const firstArg = node.arguments[0];
+                        if (firstArg && firstArg.type === 'ObjectExpression') {
+                            const idProperty = firstArg.properties.find(prop => prop.key.name === 'id');
+                            if (idProperty && idProperty.value.type === 'StringLiteral') {
+                                keys.add(idProperty.value.value);
+                            } else {
+                                possibleDynamicKeys[file] = possibleDynamicKeys[file] || [];
+                            }
+                        }
+                    }
+                }
+            });
+        } catch (error) {
+            console.error(`Error processing ${file}:`, error);
+        }
+    });
+
+    if (Object.keys(possibleDynamicKeys).length > 0) {
+        console.log(`${Object.keys(possibleDynamicKeys).length} files contain possible dynamic keys.`);
+        writeFileSync(POSSIBLE_DYNAMIC_KEYS_FILE, JSON.stringify(possibleDynamicKeys, null, 2));
+    } else if (existsSync(POSSIBLE_DYNAMIC_KEYS_FILE)) {
+        unlinkSync(POSSIBLE_DYNAMIC_KEYS_FILE);
+        console.log(`${POSSIBLE_DYNAMIC_KEYS_FILE} was deleted as there are no possible dynamic keys.`);
+    }
+
+    return keys;
+}
+
+function compareKeys() {
+    const configPath = `${process.cwd()}/.phraseapp.json`;
+    const appKeys = extractTranslationKeys();
+
+    try {
+        const phrase = JSON.parse(fs.readFileSync(configPath));
+        const translations = JSON.parse(readFileSync(`${phrase.path}/de_AT.json`, 'utf8'));
+        const dynamicKeys = JSON.parse(readFileSync(phrase.dynamicKeys, 'utf8'));
+
+        const allValidKeys = new Set(Object.keys(translations));
+        
+        let missingKeys = [...appKeys].filter(key => !allValidKeys.has(key));
+        missingKeys = missingKeys.filter(key => key != null && key !== undefined);
+
+        // Check if there are keys in dynamicKeys that are missing from allValidKeys.
+        dynamicKeys.forEach(key => {
+            if (!allValidKeys.has(key)) {
+                missingKeys.push(key);
+            } else {
+                allValidKeys.delete(key);
+            }
+        });
+
+        // 
+        const referenceKeys = new Set([...appKeys, ...dynamicKeys]);
+        const unusedKeys = [...allValidKeys].filter(key => !referenceKeys.has(key));
+        
+        if (missingKeys.length > 0) {
+            writeFileSync(MISSING_KEYS_FILE, JSON.stringify(missingKeys, null, 2));
+            console.log(`${missingKeys.length} missing keys were saved in ${MISSING_KEYS_FILE}`);
+        } else if (existsSync(MISSING_KEYS_FILE)) {
+            unlinkSync(MISSING_KEYS_FILE);
+            console.log(`${MISSING_KEYS_FILE} was deleted as there are no missing keys.`);
+        }
+
+        if (unusedKeys.length > 0) {
+            writeFileSync(UNUSED_KEYS_FILE, JSON.stringify(unusedKeys, null, 2));
+            console.log(`${unusedKeys.length} unused keys were saved in ${UNUSED_KEYS_FILE}`);
+        } else if (existsSync(UNUSED_KEYS_FILE)) {
+            unlinkSync(UNUSED_KEYS_FILE);
+            console.log(`${UNUSED_KEYS_FILE} was deleted as there are no missing keys.`);
+        }
+    } catch (error) {
+        console.error(`Error processing ${file}:`, error);
+    }
+}
+
+compareKeys();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kununu/phraseapp-cli",
-  "version": "3.1.0-beta.3",
+  "version": "4.0.0-beta.0",
   "description": "",
   "main": "index.js",
   "author": "kununu",
@@ -10,7 +10,11 @@
   },
   "dependencies": {
     "colors": "1.4.0",
-    "dotenv": "16.4.5"
+    "dotenv": "16.4.5",
+    "@babel/parser": "^7.26.9",
+    "@babel/traverse": "^7.26.9",
+    "fs": "^0.0.1-security",
+    "glob": "^11.0.1"
   },
   "devDependencies": {
     "@kununu/eslint-config": "5.0.1"