auto-lang 1.1.1 → 2.0.1

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,145 @@
+#!/usr/bin/env node
+import { Command as $ } from "commander";
+import c from "path";
+import { existsSync as g, promises as d } from "fs";
+import { createSpinner as y } from "nanospinner";
+import O from "json-to-ts";
+import x from "prettier";
+import T from "chalk";
+import F from "translate";
+class p {
+  static error(e) {
+    console.log(`${T.red(e)}`);
+  }
+  static log(e) {
+    console.log(e);
+  }
+}
+class k {
+  inputParams = {
+    from: "",
+    to: [],
+    dir: "",
+    skipExisting: !1,
+    genType: "",
+    diff: ["", ""]
+  };
+  setInputParams(e) {
+    this.inputParams = e;
+  }
+  getInputParams() {
+    return this.inputParams;
+  }
+}
+const l = new k();
+async function b(o, e, t) {
+  const { from: s, skipExisting: i } = l.getInputParams();
+  for (let [n, r] of Object.entries(o))
+    if (typeof r == "object")
+      e[n] = e[n] || {}, await b(r, e[n], t);
+    else
+      try {
+        e[n] && i || (e[n] = await F(r, {
+          from: s,
+          to: t
+        }));
+      } catch (a) {
+        console.log(`
+`), p.error(a.message), process.exit(1);
+      }
+}
+const P = (o) => {
+  const { dir: e } = l.getInputParams();
+  return new Promise(async (t, s) => {
+    let i = {};
+    const n = await K(), r = c.join(process.cwd(), e, `${o}.json`);
+    g(r) && (i = await u(r)), await b(n, i, o), t(i);
+  });
+};
+async function h() {
+  const { dir: o, genType: e } = l.getInputParams(), t = y("Creating language type file").start(), s = u(
+    c.join(process.cwd(), o, `${e}.json`)
+  ), i = O(s, {
+    rootName: "GlobalTranslationType"
+  }), n = c.join(process.cwd(), o, "types");
+  g(n) || await d.mkdir(n);
+  const r = c.join(n, "index"), a = `
+    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>;
+
+    ${i.join(`
+
+`)}
+  `, f = await x.format(a, {
+    parser: "typescript"
+  });
+  await d.writeFile(r, f), t.success({ text: "Language type file created" });
+}
+async function I() {
+  const { to: o, dir: e } = l.getInputParams();
+  let t, s, i;
+  for (let n of o)
+    s = c.join(process.cwd(), e, `${n}.json`), t = y(`Translating to ${n}...`).start(), i = await P(n), await d.writeFile(s, JSON.stringify(i, null, 2)), t.success({ text: "Complete" });
+}
+async function u(o) {
+  return JSON.parse(await d.readFile(o, { encoding: "utf-8" }));
+}
+function K() {
+  const { dir: o, from: e } = l.getInputParams(), t = c.join(process.cwd(), o, `${e}.json`);
+  return u(t);
+}
+function v(o, e) {
+  const t = [];
+  function s(i, n, r = "") {
+    for (let [a, f] of Object.entries(i)) {
+      const m = r ? `${r}.${a}` : a;
+      typeof f == "object" ? n[a] ? s(f, n[a], m) : t.push(m) : n[a] || t.push(m);
+    }
+  }
+  return s(o, e), t;
+}
+async function C() {
+  const o = y("Comparing language files").start(), { dir: e, diff: t } = l.getInputParams(), s = t[0], i = t[1], n = await u(
+    c.join(process.cwd(), e, `${s}.json`)
+  ), r = await u(
+    c.join(process.cwd(), e, `${i}.json`)
+  ), a = v(n, r);
+  p.log(`
+Missing keys in ${i}.json compared to ${s}.json
+`), p.log(a.join(`
+`) || "No missing keys"), o.success({ text: "Comparison complete" });
+}
+function N(o) {
+  Object.keys(o).length || (p.error('Invalid arguments. Use "--help" for usage'), process.exit(1));
+  const { to: e, from: t, dir: s, genType: i, diff: n } = o;
+  (t && !e || e && !t) && (p.error('"--from" and "--to" are dependent options'), process.exit(1));
+  const r = c.join(process.cwd(), s, `${t}.json`), a = c.join(process.cwd(), s, `${i}.json`);
+  if (!g(r) && t && (p.error(`File "${r}" not found`), process.exit(1)), !g(a) && i && (p.error(`File "${a}" not found`), process.exit(1)), n) {
+    n.length !== 2 && (p.error('"--diff" option requires two languages'), process.exit(1));
+    const [f, m] = n, j = c.join(process.cwd(), s, `${f}.json`), w = c.join(process.cwd(), s, `${m}.json`);
+    g(j) || (p.error(`File "${j}" not found`), process.exit(1)), g(w) || (p.error(`File "${w}" not found`), process.exit(1));
+  }
+}
+async function S() {
+  const e = (await u(c.join(process.cwd(), "package.json"))).version, t = new $();
+  t.name("auto-lang").description("Generate translation files for multiple languages (i18n)").version(e).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(), N(t.opts()), l.setInputParams(t.opts());
+  const { from: s, to: i, genType: n, diff: r } = l.getInputParams();
+  s && i && await I(), n && await h(), r && await C();
+}
+S();

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.1",
   "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": "rm -rf dist && vite build --mode watch",
+    "build": "rm -rf dist && vite build"
   },
-  "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,25 @@
   },
   "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",
+    "vite": "^6.0.3",
+    "vite-plugin-checker": "^0.8.0",
+    "webpack": "^5.97.1",
+    "webpack-cli": "^5.1.4"
   }
 }

package/src/index.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import path from 'path';
+
+import {
+  createDeclarationFile,
+  parseJsonFile,
+  showLangDiff,
+  translateFile,
+} from './utils';
+import { validateUserInput } from './utils/validation';
+import { store } from './utils/store';
+
+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,185 @@
+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';
+import { store } from './store';
+
+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`),
+  );
+
+  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';
+
+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';
+import { Logger } from './logger';
+
+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,18 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "allowJs": true,
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "noEmit": true
+  },
+  "exclude": ["node_modules"],
+  "include": ["src/**/*"]
+}

package/vite.config.ts

@@ -0,0 +1,41 @@
+import { defineConfig } from 'vite';
+import { builtinModules } from 'module';
+
+import packageJson from './package.json' assert { type: 'json' };
+import Checker from 'vite-plugin-checker';
+
+const dependencies = Object.keys(packageJson.dependencies);
+const devDependencies = Object.keys(packageJson.devDependencies);
+
+export default defineConfig(({ mode }) => {
+  const isWatch = mode === 'watch';
+
+  return {
+    build: {
+      minify: true,
+      lib: {
+        entry: 'src/index.ts',
+        formats: ['es'],
+        fileName: () => 'index.js',
+      },
+      rollupOptions: {
+        external: [
+          ...builtinModules,
+          ...dependencies,
+          ...devDependencies,
+          /^node:/,
+        ],
+      },
+      target: 'node16',
+      outDir: 'dist',
+      watch: isWatch
+        ? {
+            include: ['src/**/*'],
+            exclude: ['node_modules', 'dist'],
+            clearScreen: true,
+          }
+        : null,
+    },
+    plugins: [Checker({ typescript: true })],
+  };
+});

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