auto-lang 1.1.1 → 2.0.0

package/.prettierrc

@@ -0,0 +1,5 @@
+{
+  "bracketSpacing": true,
+  "semi": true,
+    "singleQuote": true,
+}

package/README.md

@@ -3,6 +3,9 @@
 Generate translation files for multiple languages.
 
 Write once for a single language and automatically get translated json files for others.
+
+**NEW**: Show the difference between two translation files.
+
 ## Installation
 ### Using npm
     $ npm install auto-lang
@@ -36,13 +39,16 @@ Or, using yarn:
 
 #### Options
 
-    -V, --version          output the version number
-    -f, --from <lang>      language to translate from
-    -t, --to <lang...>     languages to translate to (seperated by space)
-    -d, --dir <directory>  directory containing the language files (default: "translations")
-    -s, --skip-existing    skip existing keys during translation
-    -g, --gen-type <lang>  generate types from language file
-    -h, --help             display help for command
+```
+  -V, --version          output the version number
+  -f, --from <lang>      language to translate from
+  -t, --to <lang...>     languages to translate to (seperated by space)
+  -d, --dir <directory>  directory containing the language files (default: "translations")
+  -s, --skip-existing    skip existing keys during translation
+  -g, --gen-type <lang>  generate types from language file
+  -d, --diff <lang...>   show missing keys between two language files
+  -h, --help             display help for command
+```
 
 **Note:** `<lang>` must be a valid [ISO 639-1 language code](https://localizely.com/iso-639-1-list/).
 

package/dist/index.js

@@ -0,0 +1,88 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { Command } from 'commander';
+import path from 'path';
+import { createDeclarationFile, parseJsonFile, showLangDiff, translateFile, } from './utils/index.js';
+import { validateUserInput } from './utils/validation.js';
+import { store } from './utils/store.js';
+function main() {
+    return __awaiter(this, void 0, void 0, function () {
+        var pjson, appVersion, program, _a, from, to, genType, diff;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, parseJsonFile(path.join(process.cwd(), 'package.json'))];
+                case 1:
+                    pjson = _b.sent();
+                    appVersion = pjson.version;
+                    program = new Command();
+                    program
+                        .name('auto-lang')
+                        .description('Generate translation files for multiple languages (i18n)')
+                        .version(appVersion)
+                        .option('-f, --from <lang>', 'language to translate from')
+                        .option('-t, --to <lang...>', 'languages to translate to (seperated by space)')
+                        .option('-d, --dir <directory>', 'directory containing the language files', 'translations')
+                        .option('-s, --skip-existing', 'skip existing keys during translation')
+                        .option('-g, --gen-type <lang>', 'generate types from language file')
+                        .option('-d, --diff <lang...>', 'show missing keys between two language files')
+                        .parse();
+                    validateUserInput(program.opts());
+                    store.setInputParams(program.opts());
+                    _a = store.getInputParams(), from = _a.from, to = _a.to, genType = _a.genType, diff = _a.diff;
+                    if (!(from && to)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, translateFile()];
+                case 2:
+                    _b.sent();
+                    _b.label = 3;
+                case 3:
+                    if (!genType) return [3 /*break*/, 5];
+                    return [4 /*yield*/, createDeclarationFile()];
+                case 4:
+                    _b.sent();
+                    _b.label = 5;
+                case 5:
+                    if (!diff) return [3 /*break*/, 7];
+                    return [4 /*yield*/, showLangDiff()];
+                case 6:
+                    _b.sent();
+                    _b.label = 7;
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}
+main();

package/dist/interfaces/input-params.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/index.js

@@ -0,0 +1,249 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import path from 'path';
+import { existsSync, promises as fs } from 'fs';
+import { createSpinner } from 'nanospinner';
+import JsonToTS from 'json-to-ts';
+import prettier from 'prettier';
+import { Logger } from './logger.js';
+// @ts-expect-error
+import translate from 'translate';
+import { store } from './store.js';
+function makeTranslatedCopy(source, target, targetLang) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, from, skipExisting, _i, _b, _c, key, value, _d, _e, err_1;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    _a = store.getInputParams(), from = _a.from, skipExisting = _a.skipExisting;
+                    _i = 0, _b = Object.entries(source);
+                    _f.label = 1;
+                case 1:
+                    if (!(_i < _b.length)) return [3 /*break*/, 8];
+                    _c = _b[_i], key = _c[0], value = _c[1];
+                    if (!(typeof value === 'object')) return [3 /*break*/, 3];
+                    target[key] = target[key] || {};
+                    return [4 /*yield*/, makeTranslatedCopy(value, target[key], targetLang)];
+                case 2:
+                    _f.sent();
+                    return [3 /*break*/, 7];
+                case 3:
+                    _f.trys.push([3, 6, , 7]);
+                    if (!!(target[key] && skipExisting)) return [3 /*break*/, 5];
+                    _d = target;
+                    _e = key;
+                    return [4 /*yield*/, translate(value, {
+                            from: from,
+                            to: targetLang,
+                        })];
+                case 4:
+                    _d[_e] = _f.sent();
+                    _f.label = 5;
+                case 5: return [3 /*break*/, 7];
+                case 6:
+                    err_1 = _f.sent();
+                    console.log('\n');
+                    Logger.error(err_1.message);
+                    process.exit(1);
+                    return [3 /*break*/, 7];
+                case 7:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 8: return [2 /*return*/];
+            }
+        });
+    });
+}
+var getTranslationObject = function (lang) {
+    var dir = store.getInputParams().dir;
+    return new Promise(function (resolve, reject) { return __awaiter(void 0, void 0, void 0, function () {
+        var translatedObj, inputLangObj, outputFile;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    translatedObj = {};
+                    return [4 /*yield*/, getInputLangObject()];
+                case 1:
+                    inputLangObj = _a.sent();
+                    outputFile = path.join(process.cwd(), dir, "".concat(lang, ".json"));
+                    if (!existsSync(outputFile)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, parseJsonFile(outputFile)];
+                case 2:
+                    translatedObj = _a.sent();
+                    _a.label = 3;
+                case 3: return [4 /*yield*/, makeTranslatedCopy(inputLangObj, translatedObj, lang)];
+                case 4:
+                    _a.sent();
+                    resolve(translatedObj);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+};
+export function createDeclarationFile() {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, dir, genType, spinner, langObject, interfaces, typesDir, declarationFile, result, formattedContent;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = store.getInputParams(), dir = _a.dir, genType = _a.genType;
+                    spinner = createSpinner('Creating language type file').start();
+                    langObject = parseJsonFile(path.join(process.cwd(), dir, "".concat(genType, ".json")));
+                    interfaces = JsonToTS(langObject, {
+                        rootName: 'GlobalTranslationType',
+                    });
+                    typesDir = path.join(process.cwd(), dir, 'types');
+                    if (!!existsSync(typesDir)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, fs.mkdir(typesDir)];
+                case 1:
+                    _b.sent();
+                    _b.label = 2;
+                case 2:
+                    declarationFile = path.join(typesDir, 'index');
+                    result = "\n    type NestedKeyOf<ObjectType extends object> = {\n    [Key in keyof ObjectType & string]: ObjectType[Key] extends object\n      ? // @ts-ignore\n        `${Key}.${NestedKeyOf<ObjectType[Key]>}`\n      : `${Key}`\n    }[keyof ObjectType & string]\n\n    export type GlobalTranslation = NestedKeyOf<GlobalTranslationType>;\n\n    ".concat(interfaces.join('\n\n'), "\n  ");
+                    return [4 /*yield*/, prettier.format(result, {
+                            parser: 'typescript',
+                        })];
+                case 3:
+                    formattedContent = _b.sent();
+                    return [4 /*yield*/, fs.writeFile(declarationFile, formattedContent)];
+                case 4:
+                    _b.sent();
+                    spinner.success({ text: 'Language type file created' });
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+export function translateFile() {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, to, dir, spinner, langFile, translationObject, _i, to_1, lang;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = store.getInputParams(), to = _a.to, dir = _a.dir;
+                    _i = 0, to_1 = to;
+                    _b.label = 1;
+                case 1:
+                    if (!(_i < to_1.length)) return [3 /*break*/, 5];
+                    lang = to_1[_i];
+                    langFile = path.join(process.cwd(), dir, "".concat(lang, ".json"));
+                    spinner = createSpinner("Translating to ".concat(lang, "...")).start();
+                    return [4 /*yield*/, getTranslationObject(lang)];
+                case 2:
+                    translationObject = _b.sent();
+                    return [4 /*yield*/, fs.writeFile(langFile, JSON.stringify(translationObject, null, 2))];
+                case 3:
+                    _b.sent();
+                    spinner.success({ text: "Complete" });
+                    _b.label = 4;
+                case 4:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+export function parseJsonFile(filePath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _b = (_a = JSON).parse;
+                    return [4 /*yield*/, fs.readFile(filePath, { encoding: 'utf-8' })];
+                case 1: return [2 /*return*/, _b.apply(_a, [_c.sent()])];
+            }
+        });
+    });
+}
+function getInputLangObject() {
+    var _a = store.getInputParams(), dir = _a.dir, from = _a.from;
+    var inputFile = path.join(process.cwd(), dir, "".concat(from, ".json"));
+    return parseJsonFile(inputFile);
+}
+function getMissingKeys(source, target) {
+    var missingKeys = [];
+    function loop(source, target, path) {
+        if (path === void 0) { path = ''; }
+        for (var _i = 0, _a = Object.entries(source); _i < _a.length; _i++) {
+            var _b = _a[_i], key = _b[0], value = _b[1];
+            var currentPath = path ? "".concat(path, ".").concat(key) : key;
+            if (typeof value === 'object') {
+                if (target[key]) {
+                    loop(value, target[key], currentPath);
+                }
+                else {
+                    missingKeys.push(currentPath);
+                }
+            }
+            else {
+                if (!target[key]) {
+                    missingKeys.push(currentPath);
+                }
+            }
+        }
+    }
+    loop(source, target);
+    return missingKeys;
+}
+export function showLangDiff() {
+    return __awaiter(this, void 0, void 0, function () {
+        var spinner, _a, dir, diff, lang1, lang2, lang1Object, lang2Object, missingKeys;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    spinner = createSpinner('Comparing language files').start();
+                    _a = store.getInputParams(), dir = _a.dir, diff = _a.diff;
+                    lang1 = diff[0];
+                    lang2 = diff[1];
+                    return [4 /*yield*/, parseJsonFile(path.join(process.cwd(), dir, "".concat(lang1, ".json")))];
+                case 1:
+                    lang1Object = _b.sent();
+                    return [4 /*yield*/, parseJsonFile(path.join(process.cwd(), dir, "".concat(lang2, ".json")))];
+                case 2:
+                    lang2Object = _b.sent();
+                    missingKeys = getMissingKeys(lang1Object, lang2Object);
+                    Logger.log("\nMissing keys in ".concat(lang2, ".json compared to ").concat(lang1, ".json\n"));
+                    Logger.log(missingKeys.join('\n') || 'No missing keys');
+                    spinner.success({ text: 'Comparison complete' });
+                    return [2 /*return*/];
+            }
+        });
+    });
+}

package/dist/utils/logger.js

@@ -0,0 +1,13 @@
+import chalk from 'chalk';
+var Logger = /** @class */ (function () {
+    function Logger() {
+    }
+    Logger.error = function (message) {
+        console.log("".concat(chalk.red(message)));
+    };
+    Logger.log = function (message) {
+        console.log(message);
+    };
+    return Logger;
+}());
+export { Logger };

package/dist/utils/store.js

@@ -0,0 +1,20 @@
+var Store = /** @class */ (function () {
+    function Store() {
+        this.inputParams = {
+            from: '',
+            to: [],
+            dir: '',
+            skipExisting: false,
+            genType: '',
+            diff: ['', ''],
+        };
+    }
+    Store.prototype.setInputParams = function (params) {
+        this.inputParams = params;
+    };
+    Store.prototype.getInputParams = function () {
+        return this.inputParams;
+    };
+    return Store;
+}());
+export var store = new Store();

package/dist/utils/validation.js

@@ -0,0 +1,41 @@
+import { existsSync } from 'fs';
+import path from 'path';
+import { Logger } from './logger.js';
+export function validateUserInput(params) {
+    if (!Object.keys(params).length) {
+        Logger.error("Invalid arguments. Use \"--help\" for usage");
+        process.exit(1);
+    }
+    var to = params.to, from = params.from, dir = params.dir, genType = params.genType, diff = params.diff;
+    if ((from && !to) || (to && !from)) {
+        Logger.error("\"--from\" and \"--to\" are dependent options");
+        process.exit(1);
+    }
+    var inputFilePath = path.join(process.cwd(), dir, "".concat(from, ".json"));
+    var genTypeFilePath = path.join(process.cwd(), dir, "".concat(genType, ".json"));
+    if (!existsSync(inputFilePath) && from) {
+        Logger.error("File \"".concat(inputFilePath, "\" not found"));
+        process.exit(1);
+    }
+    if (!existsSync(genTypeFilePath) && genType) {
+        Logger.error("File \"".concat(genTypeFilePath, "\" not found"));
+        process.exit(1);
+    }
+    if (diff) {
+        if (diff.length !== 2) {
+            Logger.error("\"--diff\" option requires two languages");
+            process.exit(1);
+        }
+        var lang1 = diff[0], lang2 = diff[1];
+        var lang1File = path.join(process.cwd(), dir, "".concat(lang1, ".json"));
+        var lang2File = path.join(process.cwd(), dir, "".concat(lang2, ".json"));
+        if (!existsSync(lang1File)) {
+            Logger.error("File \"".concat(lang1File, "\" not found"));
+            process.exit(1);
+        }
+        if (!existsSync(lang2File)) {
+            Logger.error("File \"".concat(lang2File, "\" not found"));
+            process.exit(1);
+        }
+    }
+}

package/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>Webpack App</title>
+    </head>
+    <body>
+        <h1>Hello world!</h1>
+        <h2>Tip: Check your console</h2>
+    </body>
+    
+</html>

package/package.json

@@ -1,12 +1,20 @@
 {
   "name": "auto-lang",
-  "version": "1.1.1",
+  "version": "2.0.0",
   "description": "Automatically create language json files for internationalization",
   "main": "./src/index.js",
+  "type": "module",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "tsc --w",
+    "build": "rm -rf dist && tsc"
   },
-  "keywords": ["Internationalization", "node", "i18n", "translate"],
+  "keywords": [
+    "Internationalization",
+    "node",
+    "i18n",
+    "translate"
+  ],
   "author": "Lafen Lesley <lesleytech6@gmail.com> (https://github.com/lesleytech/)",
   "homepage": "https://github.com/lesleytech/auto-lang#readme",
   "repository": {
@@ -15,15 +23,23 @@
   },
   "license": "ISC",
   "bin": {
-    "auto-lang": "./src/index.js"
+    "auto-lang": "./dist/index.js"
   },
-  "type": "module",
   "dependencies": {
     "chalk": "^5.0.1",
     "commander": "^9.4.0",
     "json-to-ts": "^1.7.0",
     "nanospinner": "^1.1.0",
-    "prettier": "^2.7.1",
     "translate": "^1.4.1"
+  },
+  "devDependencies": {
+    "@types/chalk": "^2.2.4",
+    "@types/node": "^22.10.1",
+    "@webpack-cli/generators": "^3.0.7",
+    "prettier": "^3.4.2",
+    "ts-loader": "^9.5.1",
+    "typescript": "^5.7.2",
+    "webpack": "^5.97.1",
+    "webpack-cli": "^5.1.4"
   }
 }

package/src/index.ts

@@ -0,0 +1,59 @@
+import { Command } from 'commander';
+import path from 'path';
+
+import {
+  createDeclarationFile,
+  parseJsonFile,
+  showLangDiff,
+  translateFile,
+} from './utils/index.js';
+import { validateUserInput } from './utils/validation.js';
+import { store } from './utils/store.js';
+
+async function main() {
+  const pjson = await parseJsonFile(path.join(process.cwd(), 'package.json'));
+  const appVersion = pjson.version;
+
+  const program = new Command();
+
+  program
+    .name('auto-lang')
+    .description('Generate translation files for multiple languages (i18n)')
+    .version(appVersion)
+    .option('-f, --from <lang>', 'language to translate from')
+    .option(
+      '-t, --to <lang...>',
+      'languages to translate to (seperated by space)',
+    )
+    .option(
+      '-d, --dir <directory>',
+      'directory containing the language files',
+      'translations',
+    )
+    .option('-s, --skip-existing', 'skip existing keys during translation')
+    .option('-g, --gen-type <lang>', 'generate types from language file')
+    .option(
+      '-d, --diff <lang...>',
+      'show missing keys between two language files',
+    )
+    .parse();
+
+  validateUserInput(program.opts());
+  store.setInputParams(program.opts());
+
+  const { from, to, genType, diff } = store.getInputParams();
+
+  if (from && to) {
+    await translateFile();
+  }
+
+  if (genType) {
+    await createDeclarationFile();
+  }
+
+  if (diff) {
+    await showLangDiff();
+  }
+}
+
+main();

package/src/interfaces/input-params.interface.ts

@@ -0,0 +1,10 @@
+export interface IInputParams {
+  from: string;
+  to: string[];
+  dir: string;
+  genType: string;
+  skipExisting: boolean;
+  diff: [string, string];
+}
+
+export type TranslationObject = Record<string, any>;

package/src/utils/index.ts

@@ -0,0 +1,186 @@
+import path from 'path';
+import { existsSync, promises as fs } from 'fs';
+import { createSpinner, Spinner } from 'nanospinner';
+import JsonToTS from 'json-to-ts';
+import prettier from 'prettier';
+
+import { Logger } from './logger.js';
+
+// @ts-expect-error
+import translate from 'translate';
+import { TranslationObject } from '../interfaces/input-params.interface.js';
+import { store } from './store.js';
+
+async function makeTranslatedCopy(
+  source: TranslationObject,
+  target: TranslationObject,
+  targetLang: string,
+) {
+  const { from, skipExisting } = store.getInputParams();
+
+  for (let [key, value] of Object.entries(source)) {
+    if (typeof value === 'object') {
+      target[key] = target[key] || {};
+
+      await makeTranslatedCopy(value, target[key], targetLang);
+    } else {
+      try {
+        if (!(target[key] && skipExisting)) {
+          target[key] = await translate(value, {
+            from,
+            to: targetLang,
+          });
+        }
+      } catch (err: any) {
+        console.log('\n');
+        Logger.error(err.message);
+        process.exit(1);
+      }
+    }
+  }
+}
+
+const getTranslationObject = (lang: string): Promise<TranslationObject> => {
+  const { dir } = store.getInputParams();
+
+  return new Promise(async (resolve, reject) => {
+    let translatedObj: TranslationObject = {};
+    const inputLangObj = await getInputLangObject();
+
+    const outputFile = path.join(process.cwd(), dir, `${lang}.json`);
+
+    if (existsSync(outputFile)) {
+      translatedObj = await parseJsonFile(outputFile);
+    }
+
+    await makeTranslatedCopy(inputLangObj, translatedObj, lang);
+
+    resolve(translatedObj);
+  });
+};
+
+export async function createDeclarationFile() {
+  const { dir, genType } = store.getInputParams();
+  const spinner = createSpinner('Creating language type file').start();
+
+  const langObject = parseJsonFile(
+    path.join(process.cwd(), dir, `${genType}.json`),
+  );
+
+  // @ts-expect-error
+  const interfaces = JsonToTS(langObject, {
+    rootName: 'GlobalTranslationType',
+  });
+  const typesDir = path.join(process.cwd(), dir, 'types');
+
+  if (!existsSync(typesDir)) {
+    await fs.mkdir(typesDir);
+  }
+
+  const declarationFile = path.join(typesDir, 'index');
+
+  const result = `
+    type NestedKeyOf<ObjectType extends object> = {
+    [Key in keyof ObjectType & string]: ObjectType[Key] extends object
+      ? // @ts-ignore
+        \`$\{Key}.$\{NestedKeyOf<ObjectType[Key]>}\`
+      : \`$\{Key}\`
+    }[keyof ObjectType & string]
+
+    export type GlobalTranslation = NestedKeyOf<GlobalTranslationType>;
+
+    ${interfaces.join('\n\n')}
+  `;
+
+  const formattedContent = await prettier.format(result, {
+    parser: 'typescript',
+  });
+
+  await fs.writeFile(declarationFile, formattedContent);
+
+  spinner.success({ text: 'Language type file created' });
+}
+
+export async function translateFile() {
+  const { to, dir } = store.getInputParams();
+
+  let spinner: Spinner;
+  let langFile: string;
+  let translationObject: TranslationObject;
+
+  for (let lang of to) {
+    langFile = path.join(process.cwd(), dir, `${lang}.json`);
+    spinner = createSpinner(`Translating to ${lang}...`).start();
+
+    translationObject = await getTranslationObject(lang);
+
+    await fs.writeFile(langFile, JSON.stringify(translationObject, null, 2));
+
+    spinner.success({ text: `Complete` });
+  }
+}
+
+export async function parseJsonFile<T = Record<string, any>>(filePath: string) {
+  return JSON.parse(await fs.readFile(filePath, { encoding: 'utf-8' })) as T;
+}
+
+function getInputLangObject() {
+  const { dir, from } = store.getInputParams();
+
+  const inputFile = path.join(process.cwd(), dir, `${from}.json`);
+
+  return parseJsonFile(inputFile);
+}
+
+function getMissingKeys(source: TranslationObject, target: TranslationObject) {
+  const missingKeys: string[] = [];
+
+  function loop(
+    source: TranslationObject,
+    target: TranslationObject,
+    path = '',
+  ) {
+    for (let [key, value] of Object.entries(source)) {
+      const currentPath = path ? `${path}.${key}` : key;
+
+      if (typeof value === 'object') {
+        if (target[key]) {
+          loop(value, target[key], currentPath);
+        } else {
+          missingKeys.push(currentPath);
+        }
+      } else {
+        if (!target[key]) {
+          missingKeys.push(currentPath);
+        }
+      }
+    }
+  }
+
+  loop(source, target);
+
+  return missingKeys;
+}
+
+export async function showLangDiff() {
+  const spinner = createSpinner('Comparing language files').start();
+
+  const { dir, diff } = store.getInputParams();
+
+  const lang1 = diff[0];
+  const lang2 = diff[1];
+
+  const lang1Object = await parseJsonFile(
+    path.join(process.cwd(), dir, `${lang1}.json`),
+  );
+  const lang2Object = await parseJsonFile(
+    path.join(process.cwd(), dir, `${lang2}.json`),
+  );
+
+  const missingKeys = getMissingKeys(lang1Object, lang2Object);
+
+  Logger.log(`\nMissing keys in ${lang2}.json compared to ${lang1}.json\n`);
+  Logger.log(missingKeys.join('\n') || 'No missing keys');
+
+  spinner.success({ text: 'Comparison complete' });
+}

package/src/utils/logger.ts

@@ -0,0 +1,11 @@
+import chalk from 'chalk';
+
+export class Logger {
+  static error(message: string) {
+    console.log(`${chalk.red(message)}`);
+  }
+
+  static log(message: string) {
+    console.log(message);
+  }
+}

package/src/utils/store.ts

@@ -0,0 +1,22 @@
+import { IInputParams } from '../interfaces/input-params.interface.js';
+
+class Store {
+  private inputParams: IInputParams = {
+    from: '',
+    to: [],
+    dir: '',
+    skipExisting: false,
+    genType: '',
+    diff: ['', ''],
+  };
+
+  public setInputParams(params: IInputParams) {
+    this.inputParams = params;
+  }
+
+  getInputParams() {
+    return this.inputParams;
+  }
+}
+
+export const store = new Store();

package/src/utils/validation.ts

@@ -0,0 +1,55 @@
+import { existsSync } from 'fs';
+import path from 'path';
+
+import { IInputParams } from '../interfaces/input-params.interface.js';
+import { Logger } from './logger.js';
+
+export function validateUserInput(params: IInputParams) {
+  if (!Object.keys(params).length) {
+    Logger.error(`Invalid arguments. Use "--help" for usage`);
+
+    process.exit(1);
+  }
+
+  const { to, from, dir, genType, diff } = params;
+
+  if ((from && !to) || (to && !from)) {
+    Logger.error(`"--from" and "--to" are dependent options`);
+    process.exit(1);
+  }
+
+  const inputFilePath = path.join(process.cwd(), dir, `${from}.json`);
+  const genTypeFilePath = path.join(process.cwd(), dir, `${genType}.json`);
+
+  if (!existsSync(inputFilePath) && from) {
+    Logger.error(`File "${inputFilePath}" not found`);
+    process.exit(1);
+  }
+
+  if (!existsSync(genTypeFilePath) && genType) {
+    Logger.error(`File "${genTypeFilePath}" not found`);
+    process.exit(1);
+  }
+
+  if (diff) {
+    if (diff.length !== 2) {
+      Logger.error(`"--diff" option requires two languages`);
+      process.exit(1);
+    }
+
+    const [lang1, lang2] = diff;
+
+    const lang1File = path.join(process.cwd(), dir, `${lang1}.json`);
+    const lang2File = path.join(process.cwd(), dir, `${lang2}.json`);
+
+    if (!existsSync(lang1File)) {
+      Logger.error(`File "${lang1File}" not found`);
+      process.exit(1);
+    }
+
+    if (!existsSync(lang2File)) {
+      Logger.error(`File "${lang2File}" not found`);
+      process.exit(1);
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+//    "moduleResolution": "bundler"
+
+  },
+  "exclude": ["node_modules"],
+  "include": ["src/**/*"]
+}

package/src/index.js

@@ -1,138 +0,0 @@
-#!/usr/bin/env node
-
-import path from 'path';
-import {existsSync, promises as fs} from 'fs';
-import {Command} from 'commander';
-import {createSpinner} from 'nanospinner';
-import translate from 'translate';
-import JsonToTS from 'json-to-ts';
-import prettier from 'prettier';
-
-import pJson from '../package.json' assert { type: "json" };
-import {Logger} from './utils/Logger.mjs';
-import {validateOptions} from './utils/validation.mjs';
-
-const {version: appVersion} = pJson;
-
-
-const program = new Command();
-const nodeMajVer = parseInt(process.version.substring(1).split('.')[0]);
-
-if (nodeMajVer < 14) {
-  Logger.error(`Node version >= 14.x.x is required`);
-
-  process.exit(1);
-}
-
-program
-  .name('auto-lang')
-  .description('Generate translation files for multiple languages (i18n)')
-  .version(appVersion)
-  .option('-f, --from <lang>', 'language to translate from')
-  .option(
-    '-t, --to <lang...>',
-    'languages to translate to (seperated by space)'
-  )
-  .option(
-    '-d, --dir <directory>',
-    'directory containing the language files',
-    'translations'
-  )
-  .option('-s, --skip-existing', 'skip existing keys during translation')
-  .option('-g, --gen-type <lang>', 'generate types from language file')
-  .parse();
-
-const { from, to, genType, inputFile, genTypeFile, dir, skipExisting } = validateOptions(
-  program.opts()
-);
-
-const inputJson = JSON.parse(
-  await fs.readFile(from ? inputFile : genTypeFile, { encoding: 'utf-8' })
-);
-
-async function makeTranslatedCopy(obj1, obj2, options) {
-  for (let [key, value] of Object.entries(obj1)) {
-    if (typeof value === 'object') {
-      obj2[key] = obj2[key] || {};
-      await makeTranslatedCopy(value, obj2[key], options);
-    } else {
-      try {
-        if(!(obj2[key] && skipExisting)) obj2[key] = await translate(value, { from, to: options.to });
-      } catch (err) {
-        console.log('\n');
-        Logger.error(err.message);
-        process.exit(1);
-      }
-    }
-  }
-}
-
-const getTranslation = (language) =>
-  new Promise(async (resolve, reject) => {
-    let translatedObj = {};
-    const outputFile = path.join(process.cwd(), dir, `${language}.json`);
-
-    if(existsSync(outputFile)) {
-      translatedObj = JSON.parse(
-          await fs.readFile(outputFile, { encoding: 'utf-8' })
-      );
-    }
-
-    await makeTranslatedCopy(inputJson, translatedObj, { to: language });
-
-    resolve(JSON.stringify(translatedObj, null, 4));
-  });
-
-async function createDeclarationFile() {
-  const spinner = createSpinner('Creating language type file').start();
-
-  const interfaces = JsonToTS(inputJson, { rootName: 'GlobalTranslationType' });
-  const typesDir = path.join(process.cwd(), dir, 'types');
-
-  if (!existsSync(typesDir)) {
-    fs.mkdir(typesDir);
-  }
-
-  const declarationFile = path.join(typesDir, 'index.ts');
-
-  const result = `
-    type NestedKeyOf<ObjectType extends object> = {
-    [Key in keyof ObjectType & string]: ObjectType[Key] extends object
-      ? // @ts-ignore
-        \`$\{Key}.$\{NestedKeyOf<ObjectType[Key]>}\`
-      : \`$\{Key}\`
-    }[keyof ObjectType & string]
-
-    export type GlobalTranslation = NestedKeyOf<GlobalTranslationType>;
-    
-    ${interfaces.join('\n\n')}
-  `;
-
-  const formattedResult = prettier.format(result, { parser: 'typescript' });
-
-  fs.writeFile(declarationFile, formattedResult);
-  spinner.success({ text: 'Language type file created' });
-}
-
-async function translateFile() {
-  let spinner, langFile, tranlatedJson;
-
-  for (let lang of to) {
-    langFile = path.join(process.cwd(), dir, `${lang}.json`);
-    spinner = createSpinner(`Translating to ${lang}...`).start();
-
-    tranlatedJson = await getTranslation(lang);
-    // await sleep(1000);
-    await fs.writeFile(langFile, tranlatedJson);
-
-    spinner.success({ text: `Complete` });
-  }
-}
-
-if (from && to) {
-  await translateFile();
-}
-
-if (genType) {
-  await createDeclarationFile();
-}

package/src/utils/Logger.mjs

@@ -1,7 +0,0 @@
-import chalk from 'chalk';
-
-export class Logger {
-  static error(message) {
-    console.log(`${chalk.bgRed(' ERROR ')} ${message}`);
-  }
-}

package/src/utils/validation.mjs

@@ -1,37 +0,0 @@
-import chalk from 'chalk';
-import { existsSync } from 'fs';
-import path from 'path';
-
-import { Logger } from './Logger.mjs';
-
-export function validateOptions(opts) {
-  if (!Object.keys(opts).length) {
-    Logger.error(`Invalid arguments. Use ${chalk.gray('--help')} for usage`);
-
-    process.exit(1);
-  }
-
-  const { to, from, dir, genType } = opts;
-
-  if ((from && !to) || (to && !from)) {
-    Logger.error(
-      `${chalk.gray('--from')} and ${chalk.gray('--to')} are dependent options`
-    );
-    process.exit(1);
-  }
-
-  const inputFile = path.join(process.cwd(), dir, `${from}.json`);
-  const genTypeFile = path.join(process.cwd(), dir, `${genType}.json`);
-
-  if (!existsSync(inputFile) && from) {
-    Logger.error(`File "${inputFile}" not found`);
-    process.exit(1);
-  }
-
-  if (!existsSync(genTypeFile) && genType) {
-    Logger.error(`File "${genTypeFile}" not found`);
-    process.exit(1);
-  }
-
-  return { ...opts, inputFile, genTypeFile };
-}